faiss API Reference

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class AdditiveCoarseQuantizer in module faiss.swigfaiss

class AdditiveCoarseQuantizer(Index)
 |  AdditiveCoarseQuantizer(*args)
 |
 |   A "virtual" index where the elements are the residual quantizer centroids.
 |
 |  Intended for use as a coarse quantizer in an IndexIVF.
 |
 |  Method resolution order:
 |      AdditiveCoarseQuantizer
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      N/A
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids) from faiss.swigfaiss.Index
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.Index
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1) from faiss.swigfaiss.Index
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.Index
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons) from faiss.swigfaiss.Index
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.Index
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.Index
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  reset(self)
 |      N/A
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.Index
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.Index
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None) from faiss.swigfaiss.Index
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_AdditiveCoarseQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  aq
 |
 |  centroid_norms
 |      norms of centroids, useful for knn-search
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class AdditiveQuantizer in module faiss.swigfaiss

class AdditiveQuantizer(Quantizer)
 |  AdditiveQuantizer(*args, **kwargs)
 |
 |   Abstract structure for additive quantizers
 |
 |  Different from the product quantizer in which the decoded vector is the
 |  concatenation of M sub-vectors, additive quantizers sum M sub-vectors
 |  to get the decoded vector.
 |
 |  Method resolution order:
 |      AdditiveQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
 |       Compute inner-product look-up tables. Used in the centroid search
 |      functions.
 |
 |      :type xq: float
 |      :param xq:     query vector, size (n, d)
 |      :type LUT: float
 |      :param LUT:    look-up table, size (n, total_codebook_size)
 |      :type alpha: float, optional
 |      :param alpha:  compute alpha * inner-product
 |      :type ld_lut: int, optional
 |      :param ld_lut:  leading dimension of LUT
 |
 |  compute_centroid_norms(self, norms)
 |       For L2 search we need the L2 norms of the centroids
 |
 |      :type norms: float
 |      :param norms:    output norms table, size total_codebook_size
 |
 |  compute_codebook_tables(self)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |      :type centroids: float, optional
 |      :param centroids:  centroids to be added to x, size n * d
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_64bit(self, n, x)
 |      decoding function for a code in a 64-bit word
 |
 |  decode_c = decode(self, codes, x, n)
 |       Decode a set of vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  decode_qcint(self, c)
 |      decode norm by non-uniform scalar quantization
 |
 |  decode_unpacked(self, codes, x, n, ld_codes=-1)
 |       Decode a set of vectors in non-packed format
 |
 |      :type codes: int
 |      :param codes:  codes to decode, size n * ld_codes
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  encode_norm(self, norm)
 |      encode a norm into norm_bits bits
 |
 |  encode_qcint(self, x)
 |      encode norm by non-uniform scalar quantization
 |
 |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
 |      Exact L2 search, with precomputed norms
 |
 |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
 |      exact IP search
 |
 |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
 |       pack a series of code to bit-compact format
 |
 |      :type codes: int
 |      :param codes:        codes to be packed, size n * code_size
 |      :type packed_codes: uint8_t
 |      :param packed_codes: output bit-compact codes
 |      :type ld_codes: int, optional
 |      :param ld_codes:     leading dimension of codes
 |      :type norms: float, optional
 |      :param norms:        norms of the vectors (size n). Will be computed if
 |                              needed but not provided
 |      :type centroids: float, optional
 |      :param centroids:    centroids to be added to x, size n * d
 |
 |  set_derived_values(self)
 |      Train the norm quantizer
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x) from faiss.swigfaiss.Quantizer
 |       Train the quantizer
 |
 |      :type x: float
 |      :param x:       training vectors, size n * d
 |
 |  train_norm(self, n, norms)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_AdditiveQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |      number of codebooks
 |
 |  centroid_norms
 |      norms of all codebook entries (size total_codebook_size)
 |
 |  codebook_cross_products
 |      dot products of all codebook entries with the previous codebooks
 |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
 |
 |  codebook_offsets
 |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
 |      in the codebooks table of size total_codebook_size by d
 |
 |  codebooks
 |      codebooks
 |
 |  is_trained
 |      is trained or not
 |
 |  max_mem_distances
 |      norms and distance matrixes with beam search can get large, so use this
 |      to control for the amount of memory that can be allocated
 |
 |  nbits
 |      bits for each step
 |
 |  norm_bits
 |      bits allocated for the norms
 |
 |  norm_max
 |
 |  norm_min
 |      min/max for quantization of norms
 |
 |  norm_tabs
 |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
 |      store norms of codebook entries for 4-bit fastscan
 |
 |  only_8bit
 |      are all nbits = 8 (use faster decoder)
 |
 |  qnorm
 |      store and search norms
 |
 |  search_type
 |      Also determines what's in the codes
 |
 |  thisown
 |      The membership flag
 |
 |  tot_bits
 |      total number of bits (indexes + norms)
 |
 |  total_codebook_size
 |      size of the codebook in vectors
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  ST_LUT_nonorm = 1
 |
 |  ST_count = 10
 |
 |  ST_decompress = 0
 |
 |  ST_norm_cqint4 = 7
 |
 |  ST_norm_cqint8 = 6
 |
 |  ST_norm_float = 3
 |
 |  ST_norm_from_LUT = 2
 |
 |  ST_norm_lsq2x4 = 8
 |
 |  ST_norm_qint4 = 5
 |
 |  ST_norm_qint8 = 4
 |
 |  ST_norm_rq2x4 = 9
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class AlignedTableFloat32 in module faiss.swigfaiss

class AlignedTableFloat32(builtins.object)
 |  AlignedTableFloat32(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clear(self)
 |
 |  data(self, *args)
 |
 |  get(self, *args)
 |
 |  itemsize(self)
 |
 |  nbytes(self)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_AlignedTableFloat32(...)
 |
 |  round_capacity(n)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  numel
 |
 |  tab
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class AlignedTableUint16 in module faiss.swigfaiss

class AlignedTableUint16(builtins.object)
 |  AlignedTableUint16(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clear(self)
 |
 |  data(self, *args)
 |
 |  get(self, *args)
 |
 |  itemsize(self)
 |
 |  nbytes(self)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_AlignedTableUint16(...)
 |
 |  round_capacity(n)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  numel
 |
 |  tab
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class AlignedTableUint8 in module faiss.swigfaiss

class AlignedTableUint8(builtins.object)
 |  AlignedTableUint8(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clear(self)
 |
 |  data(self, *args)
 |
 |  get(self, *args)
 |
 |  itemsize(self)
 |
 |  nbytes(self)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_AlignedTableUint8(...)
 |
 |  round_capacity(n)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  numel
 |
 |  tab
 |
 |  thisown
 |      The membership flag

Python Library Documentation: function AlignedTable_to_array in module faiss.array_conversions

AlignedTable_to_array(v)
    convert an AlignedTable to a numpy array

Python Library Documentation: class ArrayInvertedLists in module faiss.swigfaiss

class ArrayInvertedLists(InvertedLists)
 |  ArrayInvertedLists(nlist_in, code_size_in)
 |
 |  simple (default) implementation as an array of inverted lists
 |
 |  Method resolution order:
 |      ArrayInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, nlist_in, code_size_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  permute_invlists(self, map)
 |      permute the inverted lists, map maps new_id to old_id
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ArrayInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  codes
 |
 |  ids
 |      Inverted lists for indexes
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class ArrayInvertedListsPanorama in module faiss.swigfaiss

class ArrayInvertedListsPanorama(ArrayInvertedLists)
 |  ArrayInvertedListsPanorama(*args)
 |
 |  Level-oriented storage as defined in the IVFFlat section of Panorama
 |  (https://www.arxiv.org/pdf/2510.00566).
 |
 |  Method resolution order:
 |      ArrayInvertedListsPanorama
 |      ArrayInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  get_cum_sums(self, list_no)
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      Panorama's layout make it impractical to support iterators as defined
 |      by Faiss (i.e. `InvertedListsIterator` API). The iterator would require
 |      to allocate and reassemble the vector at each call.
 |      Hence, we override this method to throw an error, this effectively
 |      disables the `iterate_codes` and `iterate_codes_range` methods.
 |
 |  get_single_code(self, list_no, offset)
 |      Reconstructs a single code from level-oriented storage to flat format.
 |
 |  release_codes(self, list_no, codes_in)
 |      Frees codes returned by `get_single_code`.
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ArrayInvertedListsPanorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  level_width
 |
 |  n_levels
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  cum_sums
 |
 |  pano
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ArrayInvertedLists:
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  permute_invlists(self, map)
 |      permute the inverted lists, map maps new_id to old_id
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ArrayInvertedLists:
 |
 |  codes
 |
 |  ids
 |      Inverted lists for indexes
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class AutoTuneCriterion in module faiss.swigfaiss

class AutoTuneCriterion(builtins.object)
 |  AutoTuneCriterion(*args, **kwargs)
 |
 |  Evaluation criterion. Returns a performance measure in [0,1],
 |  higher is better.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  evaluate = replacement_evaluate(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
 |
 |  evaluate_c = evaluate(self, D, I)
 |       Evaluate the criterion.
 |
 |      :type D: float
 |      :param D:  size nq * nnn
 |      :type I: int
 |      :param I:  size nq * nnn
 |      :rtype: float
 |      :return: the criterion, between 0 and 1. Larger is better.
 |
 |  set_groundtruth = replacement_set_groundtruth(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
 |
 |  set_groundtruth_c = set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
 |       Initializes the gt_D and gt_I vectors. Must be called before evaluating
 |
 |      :type gt_D_in: float
 |      :param gt_D_in:  size nq * gt_nnn
 |      :type gt_I_in: int
 |      :param gt_I_in:  size nq * gt_nnn
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_AutoTuneCriterion(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  gt_D
 |      Ground-truth distances (size nq * gt_nnn)
 |
 |  gt_I
 |      Ground-truth indexes (size nq * gt_nnn)
 |
 |  gt_nnn
 |      nb of GT NNs required to evaluate criterion
 |
 |  nnn
 |      nb of NNs that the query should request
 |
 |  nq
 |      nb of queries this criterion is evaluated on
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class BinaryInvertedListScanner in module faiss.swigfaiss

class BinaryInvertedListScanner(builtins.object)
 |  BinaryInvertedListScanner(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  distance_to_code(self, code)
 |      compute a single query-to-code distance
 |
 |  scan_codes(self, n, codes, ids, distances, labels, k)
 |       compute the distances to codes. (distances, labels) should be
 |      organized as a min- or max-heap
 |
 |      :type n: int
 |      :param n:      number of codes to scan
 |      :type codes: uint8_t
 |      :param codes:  codes to scan (n * code_size)
 |      :type ids: int
 |      :param ids:        corresponding ids (ignored if store_pairs)
 |      :type distances: int
 |      :param distances:  heap distances (size k)
 |      :type labels: int
 |      :param labels:     heap labels (size k)
 |      :type k: int
 |      :param k:          heap size
 |
 |  scan_codes_range(self, n, codes, ids, radius, result)
 |
 |  set_list(self, list_no, coarse_dis)
 |      following codes come from this inverted list
 |
 |  set_query(self, query_vector)
 |      from now on we handle this query.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BinaryInvertedListScanner(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class BitstringReader in module faiss.swigfaiss

class BitstringReader(builtins.object)
 |  BitstringReader(code, code_size)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, code_size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  read(self, nbit)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BitstringReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  code_size
 |
 |  i
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class BitstringWriter in module faiss.swigfaiss

class BitstringWriter(builtins.object)
 |  BitstringWriter(code, code_size)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, code_size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  write(self, x, nbit)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BitstringWriter(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  code_size
 |
 |  i
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class BlockInvertedLists in module faiss.swigfaiss

class BlockInvertedLists(InvertedLists)
 |  BlockInvertedLists(*args)
 |
 |   Inverted Lists that are organized by blocks.
 |
 |  Different from the regular inverted lists, the codes are organized by blocks
 |  of size block_size bytes that represent a set of n_per_block. Therefore, code
 |  allocations are always rounded up to block_size bytes. The codes are also
 |  aligned on 32-byte boundaries for use with SIMD.
 |
 |  To avoid misinterpretations, the code_size is set to (size_t)(-1), even if
 |  arguably the amount of memory consumed by code is block_size / n_per_block.
 |
 |  The writing functions add_entries and update_entries operate on block-aligned
 |  data.
 |
 |  Method resolution order:
 |      BlockInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  remove_ids(self, sel)
 |      remove ids from the InvertedLists
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |      not implemented
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BlockInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  block_size
 |
 |  codes
 |
 |  ids
 |
 |  n_per_block
 |
 |  packer
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class BufferList in module faiss.swigfaiss

class BufferList(builtins.object)
 |  BufferList(buffer_size)
 |
 |  List of temporary buffers used to store results before they are
 |  copied to the RangeSearchResult object.
 |
 |  Methods defined here:
 |
 |  __init__(self, buffer_size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, id, dis)
 |      add one result, possibly appending a new buffer if needed
 |
 |  append_buffer(self)
 |      create a new buffer
 |
 |  copy_range(self, ofs, n, dest_ids, dest_dis)
 |      copy elements ofs:ofs+n-1 seen as linear data in the buffers to
 |      tables dest_ids, dest_dis
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BufferList(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  buffer_size
 |
 |  buffers
 |
 |  thisown
 |      The membership flag
 |
 |  wp
 |      write pointer in the last buffer.

Python Library Documentation: class BufferedIOReader in module faiss.swigfaiss

class BufferedIOReader(IOReader)
 |  BufferedIOReader(*args)
 |
 |  wraps an ioreader to make buffered reads to avoid too small reads
 |
 |  Method resolution order:
 |      BufferedIOReader
 |      IOReader
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BufferedIOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  b0
 |      range of available bytes in the buffer
 |
 |  b1
 |
 |  bsz
 |
 |  buffer
 |
 |  ofs
 |      offset in input stream
 |
 |  ofs2
 |      number of bytes returned to caller
 |
 |  reader
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOReader:
 |
 |  filedescriptor(self)
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOReader:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class BufferedIOWriter in module faiss.swigfaiss

class BufferedIOWriter(IOWriter)
 |  BufferedIOWriter(*args)
 |
 |  Method resolution order:
 |      BufferedIOWriter
 |      IOWriter
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_BufferedIOWriter(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  b0
 |      amount of data in buffer
 |
 |  bsz
 |
 |  buffer
 |
 |  ofs
 |
 |  ofs2
 |      number of bytes received from caller
 |
 |  thisown
 |      The membership flag
 |
 |  writer
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOWriter:
 |
 |  filedescriptor(self)
 |
 |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOWriter:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class ByteVector in module faiss.array_conversions

class ByteVector(faiss.swigfaiss.UInt8Vector)
 |  ByteVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      ByteVector
 |      faiss.swigfaiss.UInt8Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.UInt8Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.UInt8Vector:
 |
 |  __swig_destroy__ = delete_UInt8Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.UInt8Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ByteVectorVector in module faiss.array_conversions

class ByteVectorVector(faiss.swigfaiss.UInt8VectorVector)
 |  ByteVectorVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      ByteVectorVector
 |      faiss.swigfaiss.UInt8VectorVector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.UInt8VectorVector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.UInt8VectorVector:
 |
 |  __swig_destroy__ = delete_UInt8VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.UInt8VectorVector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: function CMax_float_partition_fuzzy in module faiss.swigfaiss

CMax_float_partition_fuzzy(vals, ids, n, q_min, q_max, q_out)
     partitions the table into 0:q and q:n where all elements above q are >= all
    elements below q (for C = CMax, for CMin comparisons are reversed)

    Returns the partition threshold. The elements q:n are destroyed on output.

Python Library Documentation: function CMax_uint16_partition_fuzzy in module faiss.swigfaiss

CMax_uint16_partition_fuzzy(*args)

Python Library Documentation: function CMin_float_partition_fuzzy in module faiss.swigfaiss

CMin_float_partition_fuzzy(vals, ids, n, q_min, q_max, q_out)
     partitions the table into 0:q and q:n where all elements above q are >= all
    elements below q (for C = CMax, for CMin comparisons are reversed)

    Returns the partition threshold. The elements q:n are destroyed on output.

Python Library Documentation: function CMin_uint16_partition_fuzzy in module faiss.swigfaiss

CMin_uint16_partition_fuzzy(*args)

Python Library Documentation: class CappedInvertedLists in module faiss.swigfaiss

class CappedInvertedLists(InvertedLists)
 |  CappedInvertedLists(il, maxsize)
 |
 |  Cap list sizes to maxsize for searching, while allowing writes.
 |  Unlike StopWordsInvertedLists which skips large lists entirely,
 |  this caps each list to maxsize entries (partial scan).
 |
 |  Method resolution order:
 |      CappedInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, il, maxsize)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  real_list_size(self, list_no)
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CappedInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  il0
 |
 |  maxsize
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class CenteringTransform in module faiss.swigfaiss

class CenteringTransform(VectorTransform)
 |  CenteringTransform(d=0)
 |
 |  Subtract the mean of each component from the vectors.
 |
 |  Method resolution order:
 |      CenteringTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, d=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |      subtract the mean
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      add the mean
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |      train on n vectors.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CenteringTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  mean
 |      Mean, size d_in = d_out
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class CharVector in module faiss.array_conversions

class CharVector(faiss.swigfaiss.Int8Vector)
 |  CharVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      CharVector
 |      faiss.swigfaiss.Int8Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Int8Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Int8Vector:
 |
 |  __swig_destroy__ = delete_Int8Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Int8Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Cloner in module faiss.swigfaiss

class Cloner(builtins.object)
 |   Cloner class, useful to override classes with other cloning
 |  functions. The cloning function above just calls
 |  Cloner::clone_Index.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clone_Index(self, arg2)
 |
 |  clone_IndexIVF(self, arg2)
 |
 |  clone_VectorTransform(self, arg2)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Cloner(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Clustering in module faiss.swigfaiss

class Clustering(ClusteringParameters)
 |  Clustering(*args)
 |
 |   K-means clustering based on assignment - centroid update iterations
 |
 |  The clustering is based on an Index object that assigns training
 |  points to the centroids. Therefore, at each iteration the centroids
 |  are added to the index.
 |
 |  On output, the centroids table is set to the latest version
 |  of the centroids and they are also added to the index. If the
 |  centroids table it is not empty on input, it is also used for
 |  initialization.
 |
 |  Method resolution order:
 |      Clustering
 |      ClusteringParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  post_process_centroids(self)
 |      Post-process the centroids after each centroid update.
 |      includes optional L2 normalization and nearest integer rounding
 |
 |  train = replacement_train(self, x, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
 |      Perform clustering on a set of vectors. The index is used for assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |      index : faiss.Index
 |          Index used for assignment. The dimension of the index should be `self.d`.
 |      weights : array_like, optional
 |          Per training sample weight (size n) used when computing the weighted
 |          average to obtain the centroid (default is 1 for all training vectors).
 |
 |  train_c = train(self, n, x, index, x_weights=None)
 |       run k-means training
 |
 |      :type x: float
 |      :param x:          training vectors, size n * d
 |      :type index: :py:class:`Index`
 |      :param index:      index used for assignment
 |      :type x_weights: float, optional
 |      :param x_weights:  weight associated to each vector: NULL or size n
 |
 |  train_encoded = replacement_train_encoded(self, x, codec, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
 |      Perform clustering on a set of compressed vectors. The index is used for assignment.
 |      The decompression is performed on-the-fly.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, codec.code_size()). `dtype` must be `uint8`.
 |      codec : faiss.Index
 |          Index used to decode the vectors. Should have dimension `self.d`.
 |      index : faiss.Index
 |          Index used for assignment. The dimension of the index should be `self.d`.
 |      weights : array_like, optional
 |          Per training sample weight (size n) used when computing the weighted
 |          average to obtain the centroid (default is 1 for all training vectors).
 |
 |  train_encoded_c = train_encoded(self, nx, x_in, codec, index, weights=None)
 |       run with encoded vectors
 |
 |      in addition to train()'s parameters takes a codec as parameter
 |      to decode the input vectors.
 |
 |      :type codec: :py:class:`Index`
 |      :param codec:      codec used to decode the vectors (nullptr =
 |                            vectors are in fact floats)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Clustering(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centroids
 |       centroids (k * d)
 |      if centroids are set on input to train, they will be used as
 |      initialization
 |
 |  d
 |      dimension of the vectors
 |
 |  iteration_stats
 |      stats at every iteration of clustering
 |
 |  k
 |      nb of centroids
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ClusteringParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² initialization.
 |      Only used when init_method = AFK_MC2.
 |      Longer chains give better approximation but are slower.
 |
 |  check_input_data_for_NaNs
 |      whether to check for NaNs in an input data
 |
 |  decode_block_size
 |      when the training set is encoded, batch size of the codec decoder
 |
 |  early_stop_threshold
 |      Early stop threshold, the range is [0, 1].
 |      The value of 0 implies a default Faiss behavior,
 |      so the training process stops only if an error
 |      is unchanged from the previous iteration.
 |
 |  frozen_centroids
 |      Use the subset of centroids provided as input and do not change them
 |      during iterations
 |
 |  init_method
 |      Initialization method for centroids.
 |      RANDOM: uniform random sampling (default, current behavior)
 |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
 |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
 |
 |  int_centroids
 |      round centroids coordinates to integer after each iteration?
 |
 |  max_points_per_centroid
 |      to limit size of dataset, otherwise the training set is subsampled
 |
 |  min_points_per_centroid
 |      If fewer than this number of training vectors per centroid are provided,
 |      writes a warning. Note that fewer than 1 point per centroid raises an
 |      exception.
 |
 |  niter
 |      number of clustering iterations
 |
 |  nredo
 |      redo clustering this many times and keep the clusters with the best
 |      objective
 |
 |  seed
 |      seed for the random number generator.
 |      negative values lead to seeding an internal rng with
 |      std::high_resolution_clock.
 |
 |  spherical
 |      whether to normalize centroids after each iteration (useful for inner
 |      product clustering)
 |
 |  update_index
 |      re-train index after each iteration?
 |
 |  use_faster_subsampling
 |      Whether to use splitmix64-based random number generator for subsampling,
 |      which is faster, but may pick duplicate points.
 |
 |  verbose

Python Library Documentation: class Clustering1D in module faiss.swigfaiss

class Clustering1D(Clustering)
 |  Clustering1D(*args)
 |
 |   Exact 1D clustering algorithm
 |
 |  Since it does not use an index, it does not overload the train() function
 |
 |  Method resolution order:
 |      Clustering1D
 |      Clustering
 |      ClusteringParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  train_exact = replacement_train_exact(self, x) from faiss.class_wrappers.handle_Clustering1D.<locals>
 |      Perform clustering on a set of 1D vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, 1). `dtype` must be float32.
 |
 |  train_exact_c = train_exact(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Clustering1D(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Clustering:
 |
 |  post_process_centroids(self)
 |      Post-process the centroids after each centroid update.
 |      includes optional L2 normalization and nearest integer rounding
 |
 |  train = replacement_train(self, x, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
 |      Perform clustering on a set of vectors. The index is used for assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |      index : faiss.Index
 |          Index used for assignment. The dimension of the index should be `self.d`.
 |      weights : array_like, optional
 |          Per training sample weight (size n) used when computing the weighted
 |          average to obtain the centroid (default is 1 for all training vectors).
 |
 |  train_c = train(self, n, x, index, x_weights=None)
 |       run k-means training
 |
 |      :type x: float
 |      :param x:          training vectors, size n * d
 |      :type index: :py:class:`Index`
 |      :param index:      index used for assignment
 |      :type x_weights: float, optional
 |      :param x_weights:  weight associated to each vector: NULL or size n
 |
 |  train_encoded = replacement_train_encoded(self, x, codec, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
 |      Perform clustering on a set of compressed vectors. The index is used for assignment.
 |      The decompression is performed on-the-fly.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, codec.code_size()). `dtype` must be `uint8`.
 |      codec : faiss.Index
 |          Index used to decode the vectors. Should have dimension `self.d`.
 |      index : faiss.Index
 |          Index used for assignment. The dimension of the index should be `self.d`.
 |      weights : array_like, optional
 |          Per training sample weight (size n) used when computing the weighted
 |          average to obtain the centroid (default is 1 for all training vectors).
 |
 |  train_encoded_c = train_encoded(self, nx, x_in, codec, index, weights=None)
 |       run with encoded vectors
 |
 |      in addition to train()'s parameters takes a codec as parameter
 |      to decode the input vectors.
 |
 |      :type codec: :py:class:`Index`
 |      :param codec:      codec used to decode the vectors (nullptr =
 |                            vectors are in fact floats)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Clustering:
 |
 |  centroids
 |       centroids (k * d)
 |      if centroids are set on input to train, they will be used as
 |      initialization
 |
 |  d
 |      dimension of the vectors
 |
 |  iteration_stats
 |      stats at every iteration of clustering
 |
 |  k
 |      nb of centroids
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ClusteringParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² initialization.
 |      Only used when init_method = AFK_MC2.
 |      Longer chains give better approximation but are slower.
 |
 |  check_input_data_for_NaNs
 |      whether to check for NaNs in an input data
 |
 |  decode_block_size
 |      when the training set is encoded, batch size of the codec decoder
 |
 |  early_stop_threshold
 |      Early stop threshold, the range is [0, 1].
 |      The value of 0 implies a default Faiss behavior,
 |      so the training process stops only if an error
 |      is unchanged from the previous iteration.
 |
 |  frozen_centroids
 |      Use the subset of centroids provided as input and do not change them
 |      during iterations
 |
 |  init_method
 |      Initialization method for centroids.
 |      RANDOM: uniform random sampling (default, current behavior)
 |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
 |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
 |
 |  int_centroids
 |      round centroids coordinates to integer after each iteration?
 |
 |  max_points_per_centroid
 |      to limit size of dataset, otherwise the training set is subsampled
 |
 |  min_points_per_centroid
 |      If fewer than this number of training vectors per centroid are provided,
 |      writes a warning. Note that fewer than 1 point per centroid raises an
 |      exception.
 |
 |  niter
 |      number of clustering iterations
 |
 |  nredo
 |      redo clustering this many times and keep the clusters with the best
 |      objective
 |
 |  seed
 |      seed for the random number generator.
 |      negative values lead to seeding an internal rng with
 |      std::high_resolution_clock.
 |
 |  spherical
 |      whether to normalize centroids after each iteration (useful for inner
 |      product clustering)
 |
 |  update_index
 |      re-train index after each iteration?
 |
 |  use_faster_subsampling
 |      Whether to use splitmix64-based random number generator for subsampling,
 |      which is faster, but may pick duplicate points.
 |
 |  verbose

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class ClusteringInitialization in module faiss.swigfaiss

class ClusteringInitialization(builtins.object)
 |  ClusteringInitialization(d, k)
 |
 |  Centroid initialization for k-means clustering.
 |
 |  This class provides different algorithms for selecting initial centroids
 |  before running k-means iterations. Good initialization can significantly
 |  improve clustering quality and convergence speed.
 |
 |  Example usage:
 |
 |  .. code-block:: c++
 |
 |          ClusteringInitialization init(128, 1000);  // d=128, k=1000
 |          init.method = ClusteringInitMethod::KMEANS_PLUS_PLUS;
 |          init.seed = 42;
 |
 |          std::vector<float> centroids(128 * 1000);
 |          init.init_centroids(n, x, centroids.data());
 |
 |  Methods defined here:
 |
 |  __init__(self, d, k)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  init_centroids(self, n, x, centroids, n_existing_centroids=0, existing_centroids=None)
 |      Initialize k centroids from n input vectors.
 |
 |      :type n: int
 |      :param n:          number of input vectors
 |      :type x: float
 |      :param x:          input vectors, size (n, d), row-major
 |      :type centroids: float
 |      :param centroids:  output centroids, size (k, d), row-major
 |      :type n_existing_centroids: int, optional
 |      :param n_existing_centroids:  number of pre-existing centroids to
 |          consider
 |                                       when computing distances (for k-means++ and
 |                                       AFK-MC²). These centroids are not modified.
 |      :type existing_centroids: float, optional
 |      :param existing_centroids:    pre-existing centroids, size
 |                                       (n_existing_centroids, d), row-major.
 |                                       New centroids will be selected to be far
 |                                       from these existing ones.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ClusteringInitialization(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² (only used when method = AFK_MC2).
 |      Longer chains give better approximation to k-means++ but are slower.
 |
 |  d
 |      vector dimension
 |
 |  k
 |      number of centroids to initialize
 |
 |  method
 |      Initialization method to use
 |
 |  seed
 |      Random seed.
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ClusteringIterationStats in module faiss.swigfaiss

class ClusteringIterationStats(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ClusteringIterationStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  imbalance_factor
 |      imbalance factor of iteration
 |
 |  nsplit
 |      number of cluster splits
 |
 |  obj
 |      objective values (sum of distances reported by index)
 |
 |  thisown
 |      The membership flag
 |
 |  time
 |      seconds for iteration
 |
 |  time_search
 |      seconds for just search

Python Library Documentation: class ClusteringIterationStatsVector in module faiss.swigfaiss

class ClusteringIterationStatsVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ClusteringIterationStatsVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ClusteringParameters in module faiss.swigfaiss

class ClusteringParameters(builtins.object)
 |   Class for the clustering parameters. Can be passed to the
 |  constructor of the Clustering object.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ClusteringParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² initialization.
 |      Only used when init_method = AFK_MC2.
 |      Longer chains give better approximation but are slower.
 |
 |  check_input_data_for_NaNs
 |      whether to check for NaNs in an input data
 |
 |  decode_block_size
 |      when the training set is encoded, batch size of the codec decoder
 |
 |  early_stop_threshold
 |      Early stop threshold, the range is [0, 1].
 |      The value of 0 implies a default Faiss behavior,
 |      so the training process stops only if an error
 |      is unchanged from the previous iteration.
 |
 |  frozen_centroids
 |      Use the subset of centroids provided as input and do not change them
 |      during iterations
 |
 |  init_method
 |      Initialization method for centroids.
 |      RANDOM: uniform random sampling (default, current behavior)
 |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
 |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
 |
 |  int_centroids
 |      round centroids coordinates to integer after each iteration?
 |
 |  max_points_per_centroid
 |      to limit size of dataset, otherwise the training set is subsampled
 |
 |  min_points_per_centroid
 |      If fewer than this number of training vectors per centroid are provided,
 |      writes a warning. Note that fewer than 1 point per centroid raises an
 |      exception.
 |
 |  niter
 |      number of clustering iterations
 |
 |  nredo
 |      redo clustering this many times and keep the clusters with the best
 |      objective
 |
 |  seed
 |      seed for the random number generator.
 |      negative values lead to seeding an internal rng with
 |      std::high_resolution_clock.
 |
 |  spherical
 |      whether to normalize centroids after each iteration (useful for inner
 |      product clustering)
 |
 |  thisown
 |      The membership flag
 |
 |  update_index
 |      re-train index after each iteration?
 |
 |  use_faster_subsampling
 |      Whether to use splitmix64-based random number generator for subsampling,
 |      which is faster, but may pick duplicate points.
 |
 |  verbose

Python Library Documentation: class CodePacker in module faiss.swigfaiss

class CodePacker(builtins.object)
 |  CodePacker(*args, **kwargs)
 |
 |  Packing consists in combining a fixed number of codes of constant size
 |  (code_size) into a block of data where they may (or may not) be interleaved
 |  for efficient consumption by distance computation kernels. This exists for
 |  the "fast_scan" indexes on CPU and for some GPU kernels.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clone(self)
 |
 |  pack_1 = replacement_pack_1(self, x, offset, block) from faiss.class_wrappers.handle_CodePacker.<locals>
 |
 |  pack_1_c = pack_1(self, flat_code, offset, block)
 |
 |  pack_all(self, flat_codes, block)
 |
 |  unpack_1 = replacement_unpack_1(self, block, offset) from faiss.class_wrappers.handle_CodePacker.<locals>
 |
 |  unpack_1_c = unpack_1(self, block, offset, flat_code)
 |
 |  unpack_all(self, block, flat_codes)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CodePacker(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  block_size
 |
 |  code_size
 |
 |  nvec
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class CodePackerFlat in module faiss.swigfaiss

class CodePackerFlat(CodePacker)
 |  CodePackerFlat(code_size)
 |
 |  Trivial code packer where codes are stored one by one
 |
 |  Method resolution order:
 |      CodePackerFlat
 |      CodePacker
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, code_size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clone(self)
 |
 |  pack_1 = replacement_pack_1(self, x, offset, block) from faiss.class_wrappers.handle_CodePacker.<locals>
 |
 |  pack_1_c = pack_1(self, flat_code, offset, block)
 |
 |  pack_all(self, flat_codes, block)
 |
 |  unpack_1 = replacement_unpack_1(self, block, offset) from faiss.class_wrappers.handle_CodePacker.<locals>
 |
 |  unpack_1_c = unpack_1(self, block, offset, flat_code)
 |
 |  unpack_all(self, block, flat_codes)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CodePackerFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from CodePacker:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  block_size
 |
 |  code_size
 |
 |  nvec

Python Library Documentation: class CodeSet in module faiss.swigfaiss

class CodeSet(builtins.object)
 |  CodeSet(d_in)
 |
 |  Methods defined here:
 |
 |  __init__(self, d_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  insert = replacement_insert(self, codes, inserted=None) from faiss.class_wrappers.handle_CodeSet.<locals>
 |
 |  insert_c = insert(self, n, codes, inserted)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CodeSet(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |
 |  s
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class CombinerRangeKNNfloat in module faiss.swigfaiss

class CombinerRangeKNNfloat(builtins.object)
 |  CombinerRangeKNNfloat(nq_in, k_in, r2_in, keep_max_in)
 |
 |   This class is used to combine range and knn search results
 |  in contrib.exhaustive_search.range_search_gpu
 |
 |  Methods defined here:
 |
 |  __init__(self, nq_in, k_in, r2_in, keep_max_in)
 |      whether to keep max values instead of min.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_sizes(self, L_res)
 |      size nq + 1
 |
 |  write_result(self, D_res, I_res)
 |      Phase 2: caller allocates D_res and I_res (size L_res[nq])
 |      Phase 3: fill in D_res and I_res
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CombinerRangeKNNfloat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  D
 |      size nq * k
 |
 |  D_remain
 |      size nrange + 1
 |
 |  I
 |      Knn search results
 |
 |  I_remain
 |      size lim_remain[nrange]
 |
 |  L_res
 |      size lim_remain[nrange]
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  k
 |      nb of queries
 |
 |  keep_max
 |      range search radius
 |
 |  lim_remain
 |      mask for where knn results are valid, size nq
 |
 |  mask
 |      size nq * k
 |      optional: range search results (ignored if mask is NULL)
 |
 |  nq
 |
 |  r2
 |      number of neighbors for the knn search part
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class CombinerRangeKNNint16 in module faiss.swigfaiss

class CombinerRangeKNNint16(builtins.object)
 |  CombinerRangeKNNint16(nq_in, k_in, r2_in, keep_max_in)
 |
 |   This class is used to combine range and knn search results
 |  in contrib.exhaustive_search.range_search_gpu
 |
 |  Methods defined here:
 |
 |  __init__(self, nq_in, k_in, r2_in, keep_max_in)
 |      whether to keep max values instead of min.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_sizes(self, L_res)
 |      size nq + 1
 |
 |  write_result(self, D_res, I_res)
 |      Phase 2: caller allocates D_res and I_res (size L_res[nq])
 |      Phase 3: fill in D_res and I_res
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_CombinerRangeKNNint16(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  D
 |      size nq * k
 |
 |  D_remain
 |      size nrange + 1
 |
 |  I
 |      Knn search results
 |
 |  I_remain
 |      size lim_remain[nrange]
 |
 |  L_res
 |      size lim_remain[nrange]
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  k
 |      nb of queries
 |
 |  keep_max
 |      range search radius
 |
 |  lim_remain
 |      mask for where knn results are valid, size nq
 |
 |  mask
 |      size nq * k
 |      optional: range search results (ignored if mask is NULL)
 |
 |  nq
 |
 |  r2
 |      number of neighbors for the knn search part
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ComputeCodesAddCentroidsLUT0MemoryPool in module faiss.swigfaiss

class ComputeCodesAddCentroidsLUT0MemoryPool(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ComputeCodesAddCentroidsLUT0MemoryPool(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  codes
 |
 |  distances
 |
 |  norms
 |
 |  refine_beam_pool
 |
 |  residuals
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ComputeCodesAddCentroidsLUT1MemoryPool in module faiss.swigfaiss

class ComputeCodesAddCentroidsLUT1MemoryPool(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ComputeCodesAddCentroidsLUT1MemoryPool(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  codes
 |
 |  distances
 |
 |  query_cp
 |
 |  query_norms
 |
 |  refine_beam_lut_pool
 |
 |  residuals
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class HStackInvertedLists in module faiss.swigfaiss

class HStackInvertedLists(ReadOnlyInvertedLists)
 |  HStackInvertedLists(n_il, ils)
 |
 |  Horizontal stack of inverted lists
 |
 |  Method resolution order:
 |      HStackInvertedLists
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, n_il, ils)
 |      build InvertedLists by concatenating nil of them
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_HStackInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  ils
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ReadOnlyInvertedLists:
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class DefaultShardingFunction in module faiss.swigfaiss

class DefaultShardingFunction(ShardingFunction)
 |  Method resolution order:
 |      DefaultShardingFunction
 |      ShardingFunction
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, i, shard_count)
 |      Call self as a function.
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_DefaultShardingFunction(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ShardingFunction:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class DirectMap in module faiss.swigfaiss

class DirectMap(builtins.object)
 |  Direct map: a way to map back from ids to inverted lists
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_single_id(self, id, list_no, offset)
 |      non thread-safe version
 |
 |  check_can_add(self, ids)
 |      update the direct_map
 |
 |       throw if Array and ids is not NULL
 |
 |  clear(self)
 |      remove all entries
 |
 |  get(self, id)
 |      get an entry
 |
 |  no(self)
 |      for quick checks
 |
 |  remove_ids(self, sel, invlists)
 |      operations on inverted lists that require translation with a DirectMap
 |
 |       remove ids from the InvertedLists, possibly using the direct map
 |
 |  set_type(self, new_type, invlists, ntotal)
 |      set type and initialize
 |
 |  update_codes(self, invlists, n, ids, list_nos, codes)
 |      update entries, using the direct map
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_DirectMap(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  array
 |      map for direct access to the elements. Map ids to LO-encoded entries.
 |
 |  hashtable
 |
 |  thisown
 |      The membership flag
 |
 |  type
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  Array = 1
 |
 |  DMT_count = 3
 |
 |  Hashtable = 2
 |
 |  NoMap = 0

Python Library Documentation: class DirectMapAdd in module faiss.swigfaiss

class DirectMapAdd(builtins.object)
 |  DirectMapAdd(direct_map, n, xids)
 |
 |  Thread-safe way of updating the direct_map
 |
 |  Methods defined here:
 |
 |  __init__(self, direct_map, n, xids)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, i, list_no, offset)
 |      add vector i (with id xids[i]) at list_no and offset
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_DirectMapAdd(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  all_ofs
 |
 |  direct_map
 |
 |  n
 |
 |  ntotal
 |
 |  thisown
 |      The membership flag
 |
 |  type
 |
 |  xids

Python Library Documentation: class DistanceComputer in module faiss.swigfaiss

class DistanceComputer(builtins.object)
 |  DistanceComputer(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __call__(self, i)
 |      compute distance of vector i to current query
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
 |      compute distances of current query to 4 stored vectors.
 |      certain DistanceComputer implementations may benefit
 |      heavily from this.
 |
 |  set_query(self, x)
 |      called before computing distances. Pointer x should remain valid
 |      while operator () is called
 |
 |  symmetric_dis(self, i, j)
 |      compute distance between two stored vectors
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_DistanceComputer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class DoubleVector in module faiss.array_conversions

class DoubleVector(faiss.swigfaiss.Float64Vector)
 |  DoubleVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      DoubleVector
 |      faiss.swigfaiss.Float64Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Float64Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Float64Vector:
 |
 |  __swig_destroy__ = delete_Float64Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Float64Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class Embedding in module faiss.swigfaiss

class Embedding(builtins.object)
 |  Embedding(*args)
 |
 |  minimal translation of nn.Embedding
 |
 |  Methods defined here:
 |
 |  __call__(self, arg2)
 |      Call self as a function.
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Embedding.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  data(self, *args)
 |
 |  from_array(self, array) from faiss.class_wrappers.handle_Embedding.<locals>
 |      copy weights from numpy array
 |
 |  from_torch(self, emb) from faiss.class_wrappers.handle_Embedding.<locals>
 |      copy weights from torch.Embedding
 |
 |  original_init = __init__(self, num_embeddings, embedding_dim)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Embedding(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  embedding_dim
 |
 |  num_embeddings
 |
 |  thisown
 |      The membership flag
 |
 |  weight

Python Library Documentation: class EnumeratedVectors in module faiss.swigfaiss

class EnumeratedVectors(builtins.object)
 |  EnumeratedVectors(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, code, c)
 |      decode it
 |
 |  decode_multi(self, nc, codes, c)
 |
 |  encode(self, x)
 |      encode a vector from a collection
 |
 |  encode_multi(self, nc, c, codes)
 |
 |  find_nn(self, n, codes, nq, xq, idx, dis)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_EnumeratedVectors(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dim
 |
 |  nv
 |      size of the collection
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ExtraBitsFactors in module faiss.swigfaiss

class ExtraBitsFactors(builtins.object)
 |   Additional factors for multi-bit RaBitQ (nb_bits > 1).
 |  Used to store normalization and scaling factors for the refinement bits
 |  that encode additional precision beyond the sign bit.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ExtraBitsFactors(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  f_add_ex
 |
 |  f_rescale_ex
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class FFN in module faiss.swigfaiss

class FFN(builtins.object)
 |  FFN(d, h)
 |
 |  Feed forward layer that expands to a hidden dimension, applies a ReLU non
 |  linearity and maps back to the original dimension
 |
 |  Methods defined here:
 |
 |  __call__(self, x)
 |      Call self as a function.
 |
 |  __init__(self, d, h)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_FFN(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  linear1
 |
 |  linear2
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class FastScanDistancePostProcessing in module faiss.swigfaiss

class FastScanDistancePostProcessing(builtins.object)
 |  Simple context object that holds processors for FastScan operations.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Default constructor - no processing
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  has_norm_scaling(self)
 |      Check if norm scaling is enabled
 |
 |  has_query_processing(self)
 |      Check if query factors processing is enabled
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_FastScanDistancePostProcessing(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  centered
 |      RaBitQ centered scalar quantizer override.
 |      Only used when qb > 0 (i.e., when params are overridden).
 |
 |  nprobe
 |      The nprobe value used when allocating query_factors storage.
 |      This is needed because the allocation size (n * nprobe) may use a
 |      different nprobe than index->nprobe if search params override it.
 |      Set to 0 to use index->nprobe as fallback.
 |
 |  pq2x4_scale
 |      Norm scaling processor for Additive Quantizers.
 |      The scale is encoded in a 2x4 bit PQ table, then scaled by this int.
 |      Set to 0 if unused.
 |
 |  qb
 |      RaBitQ query quantization bits override.
 |      Set to 0 to use the index default (index->qb).
 |
 |  query_factors
 |      Query factors data pointer for RaBitQ (nullptr if not needed)
 |      This pointer should point to the beginning of the relevant
 |      QueryFactorsData subset for this context.
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class FastScanStats in module faiss.swigfaiss

class FastScanStats(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_FastScanStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  t0
 |
 |  t1
 |
 |  t2
 |
 |  t3
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class FileIOReader in module faiss.swigfaiss

class FileIOReader(IOReader)
 |  FileIOReader(*args)
 |
 |  Method resolution order:
 |      FileIOReader
 |      IOReader
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  filedescriptor(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_FileIOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  f
 |
 |  need_close
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOReader:
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOReader:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class FileIOWriter in module faiss.swigfaiss

class FileIOWriter(IOWriter)
 |  FileIOWriter(*args)
 |
 |  Method resolution order:
 |      FileIOWriter
 |      IOWriter
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  filedescriptor(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_FileIOWriter(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  f
 |
 |  need_close
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOWriter:
 |
 |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOWriter:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class FlatCodesDistanceComputer in module faiss.swigfaiss

class FlatCodesDistanceComputer(DistanceComputer)
 |  FlatCodesDistanceComputer(*args, **kwargs)
 |
 |  Method resolution order:
 |      FlatCodesDistanceComputer
 |      DistanceComputer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, i)
 |      compute distance of vector i to current query
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  distance_to_code(self, code)
 |      compute distance of current query to an encoded vector
 |
 |  partial_dot_product(self, arg2, arg3, arg4)
 |      Computes a partial dot product over a slice of the query vector.
 |      The slice is defined by the following parameters:
 |        — `offset`: the starting index of the first component to include
 |        — `num_components`: the number of consecutive components to include
 |
 |      Components refer to raw dimensions of the flat (uncompressed) query
 |      vector.
 |
 |      By default, this method throws an error, as it is only implemented
 |      in specific subclasses such as `FlatL2Dis`. Other flat distance
 |      computers may override this when partial dot product support is needed.
 |
 |      Over time, this method might be changed to a pure virtual function (`=
 |      0`) to enforce implementation in subclasses that require this
 |      functionality.
 |
 |      This method is not part of the generic `DistanceComputer` interface
 |      because for compressed representations (e.g., product quantization),
 |      calling `partial_dot_product` repeatedly is often less efficient than
 |      computing the full distance at once.
 |
 |      Supporting efficient partial scans generally requires a different memory
 |      layout, such as interleaved blocks that keep SIMD lanes full. This is a
 |      non-trivial change and not supported in the current flat layout.
 |
 |      For more details on partial (or chunked) dot product computations and
 |      the performance trade-offs involved, refer to the Panorama paper:
 |      https://arxiv.org/pdf/2510.00566
 |
 |  partial_dot_product_batch_4(self, idx0, idx1, idx2, idx3, dp0, dp1, dp2, dp3, offset, num_components)
 |      Compute partial dot products of current query to 4 stored vectors.
 |      See `partial_dot_product` for more details.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_FlatCodesDistanceComputer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  code_size
 |
 |  codes
 |
 |  q
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from DistanceComputer:
 |
 |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
 |      compute distances of current query to 4 stored vectors.
 |      certain DistanceComputer implementations may benefit
 |      heavily from this.
 |
 |  set_query(self, x)
 |      called before computing distances. Pointer x should remain valid
 |      while operator () is called
 |
 |  symmetric_dis(self, i, j)
 |      compute distance between two stored vectors
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from DistanceComputer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class Float32Vector in module faiss.swigfaiss

class Float32Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Float32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Float32VectorVector in module faiss.swigfaiss

class Float32VectorVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Float32VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Float64Vector in module faiss.swigfaiss

class Float64Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Float64Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class FloatVector in module faiss.array_conversions

class FloatVector(faiss.swigfaiss.Float32Vector)
 |  FloatVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      FloatVector
 |      faiss.swigfaiss.Float32Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Float32Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Float32Vector:
 |
 |  __swig_destroy__ = delete_Float32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Float32Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class FloatVectorVector in module faiss.array_conversions

class FloatVectorVector(faiss.swigfaiss.Float32VectorVector)
 |  FloatVectorVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      FloatVectorVector
 |      faiss.swigfaiss.Float32VectorVector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Float32VectorVector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Float32VectorVector:
 |
 |  __swig_destroy__ = delete_Float32VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Float32VectorVector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class HNSW in module faiss.swigfaiss

class HNSW(builtins.object)
 |  HNSW(M=32)
 |
 |  Methods defined here:
 |
 |  __init__(self, M=32)
 |      only mandatory parameter: nb of neighbors
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_links_starting_from(self, ptdis, pt_id, nearest, d_nearest, level, locks, vt, keep_max_size_level0=False)
 |
 |  add_with_locks(self, ptdis, pt_level, pt_id, locks, vt, keep_max_size_level0=False)
 |       add point pt_id on all levels <= pt_level and build the link
 |      structure for them.
 |
 |  clear_neighbor_tables(self, level)
 |
 |  cum_nb_neighbors(self, layer_no)
 |      cumulative nb up to (and excluding) this level
 |
 |  fill_with_random_links(self, n)
 |      add n random levels to table (for debugging...)
 |
 |  nb_neighbors(self, layer_no)
 |      nb of neighbors for this level
 |
 |  neighbor_range(self, no, layer_no, begin, end)
 |      range of entries in the neighbors table of vertex no at layer_no
 |
 |  permute_entries(self, map)
 |
 |  prepare_level_tab(self, n, preset_levels=False)
 |
 |  print_neighbor_stats(self, level)
 |
 |  random_level(self)
 |      pick a random level for a new point
 |
 |  reset(self)
 |
 |  search(self, qdis, index, res, vt, params=None)
 |      Search interface for 1 point, single thread
 |
 |      NOTE: We pass a reference to the index itself to allow for additional
 |      state information to be passed (used for Panorama progressive pruning).
 |      The alternative would be to override both HNSW::search and
 |      HNSWIndex::search, which would be a nuisance of code duplication.
 |
 |  search_level_0(self, qdis, res, nprobe, nearest_i, nearest_d, search_type, search_stats, vt, params=None)
 |      search only in level 0 from a given vertex
 |
 |  set_default_probas(self, M, levelMult)
 |      initialize the assign_probas and cum_nneighbor_per_level to
 |      have 2*M links on level 0 and M links on levels > 0
 |
 |  set_nb_neighbors(self, level_no, n)
 |      set nb of neighbors for this level (before adding anything)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_HNSW(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  assign_probas
 |      assignment probability to each layer (sum=1)
 |
 |  check_relative_distance
 |      during search: do we check whether the next best distance is good
 |      enough?
 |
 |  cum_nneighbor_per_level
 |      number of neighbors stored per layer (cumulative), should not
 |      be changed after first add
 |
 |  efConstruction
 |      expansion factor at construction time
 |
 |  efSearch
 |      expansion factor at search time
 |
 |  entry_point
 |      entry point in the search structure (one of the points with maximum
 |      level
 |
 |  is_panorama
 |      use Panorama progressive pruning in search
 |
 |  is_similarity
 |      distance comparison semantics: when true, distances are treated as
 |      similarity scores (larger is better). Default false matches the
 |      historical L2/Hamming behavior (smaller is better).
 |      Not serialized: must be re-set by the owning Index after loading.
 |
 |  levels
 |      level of each vector (base level = 1), size = ntotal
 |
 |  max_level
 |      maximum level
 |
 |  neighbors
 |      neighbors[offsets[i]:offsets[i+1]] is the list of neighbors of vector i
 |      for all levels. this is where all storage goes.
 |
 |  offsets
 |      offsets[i] is the offset in the neighbors array where vector i is stored
 |      size ntotal + 1
 |
 |  prune_headroom
 |      when pruning, leave room for more neighbors to avoid O(n^2)
 |      costs and lock contention on frequently-pruned nodes.
 |
 |  rng
 |
 |  search_bounded_queue
 |      use bounded queue during exploration
 |
 |  thisown
 |      The membership flag
 |
 |  use_visited_hashset

Python Library Documentation: class HNSWStats in module faiss.swigfaiss

class HNSWStats(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  combine(self, other)
 |
 |  reset(self)
 |      number of hops aka number of edges traversed
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_HNSWStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n1
 |
 |  n2
 |      number of vectors searched
 |
 |  ndis
 |      number of queries for which the candidate list is exhausted
 |
 |  nhops
 |      number of distances computed
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class HStackInvertedLists in module faiss.swigfaiss

class HStackInvertedLists(ReadOnlyInvertedLists)
 |  HStackInvertedLists(n_il, ils)
 |
 |  Horizontal stack of inverted lists
 |
 |  Method resolution order:
 |      HStackInvertedLists
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, n_il, ils)
 |      build InvertedLists by concatenating nil of them
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_HStackInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  ils
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ReadOnlyInvertedLists:
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class HadamardRotation in module faiss.swigfaiss

class HadamardRotation(VectorTransform)
 |  HadamardRotation(*args)
 |
 |   Three rounds of random sign-flip + Fast Walsh-Hadamard Transform.
 |  Produces a pseudo-random rotation in O(d log d) time.
 |  d_out is the smallest power of 2 >= d_in (zero-padded as needed).
 |
 |  Method resolution order:
 |      HadamardRotation
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |       apply the transformation and return the result in a provided matrix
 |      :type n: int
 |      :param n: number of vectors to transform
 |      :type x: float
 |      :param x: input vectors, size n * d_in
 |      :type xt: float
 |      :param xt: output vectors, size n * d_out
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  init(self, seed_in)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x) from faiss.swigfaiss.VectorTransform
 |      reverse transformation. May not be implemented or may return
 |      approximate result
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_HadamardRotation(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  seed
 |
 |  signs1
 |      Sign-flip vectors, each of size d_out, generated from seed.
 |
 |  signs2
 |
 |  signs3
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class IDSelector in module faiss.swigfaiss

class IDSelector(builtins.object)
 |  IDSelector(*args, **kwargs)
 |
 |  Encapsulates a set of ids to handle.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IDSelectorAll in module faiss.swigfaiss

class IDSelectorAll(IDSelector)
 |  selects all entries (useful for benchmarking)
 |
 |  Method resolution order:
 |      IDSelectorAll
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, arg2)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorAll(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorAnd in module faiss.swigfaiss

class IDSelectorAnd(IDSelector)
 |  IDSelectorAnd(*args)
 |
 |  does an AND operation on the two given IDSelector's is_membership
 |  results.
 |
 |  Method resolution order:
 |      IDSelectorAnd
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorAnd(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lhs
 |
 |  rhs
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorArray in module faiss.swigfaiss

class IDSelectorArray(IDSelector)
 |  IDSelectorArray(*args)
 |
 |   Simple array of elements
 |
 |  is_member calls are very inefficient, but some operations can use the ids
 |  directly.
 |
 |  Method resolution order:
 |      IDSelectorArray
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_IDSelectorSubset.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  original_init = __init__(self, n, ids)
 |       Construct with an array of ids to process
 |
 |      :type n: int
 |      :param n: number of ids to store
 |      :type ids: int
 |      :param ids: elements to store. The pointer should remain valid during
 |                     IDSelectorArray's lifetime
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorArray(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  ids
 |
 |  n
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorBatch in module faiss.swigfaiss

class IDSelectorBatch(IDSelector)
 |  IDSelectorBatch(*args)
 |
 |   Ids from a set.
 |
 |  Repetitions of ids in the indices set passed to the constructor does not hurt
 |  performance.
 |
 |  The hash function used for the bloom filter and GCC's implementation of
 |  unordered_set are just the least significant bits of the id. This works fine
 |  for random ids or ids in sequences but will produce many hash collisions if
 |  lsb's are always the same
 |
 |  Method resolution order:
 |      IDSelectorBatch
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_IDSelectorSubset.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  original_init = __init__(self, n, indices)
 |       Construct with an array of ids to process
 |
 |      :type n: int
 |      :param n: number of ids to store
 |      :param ids: elements to store. The pointer can be released after
 |                     construction
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorBatch(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  mask
 |
 |  nbits
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorBitmap in module faiss.swigfaiss

class IDSelectorBitmap(IDSelector)
 |  IDSelectorBitmap(*args)
 |
 |  One bit per element. Constructed with a bitmap, size ceil(n / 8).
 |
 |  Method resolution order:
 |      IDSelectorBitmap
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_IDSelectorSubset.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  original_init = __init__(self, n, bitmap)
 |       Construct with a binary mask
 |
 |      :type n: int
 |      :param n: size of the bitmap array
 |      :type bitmap: uint8_t
 |      :param bitmap: id will be selected iff id / 8 < n and bit number
 |                        (i%8) of bitmap[floor(i / 8)] is 1.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorBitmap(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  bitmap
 |
 |  n
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorNot in module faiss.swigfaiss

class IDSelectorNot(IDSelector)
 |  IDSelectorNot(*args)
 |
 |  reverts the membership test of another selector
 |
 |  Method resolution order:
 |      IDSelectorNot
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorNot(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  sel
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorOr in module faiss.swigfaiss

class IDSelectorOr(IDSelector)
 |  IDSelectorOr(*args)
 |
 |  does an OR operation on the two given IDSelector's is_membership
 |  results.
 |
 |  Method resolution order:
 |      IDSelectorOr
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorOr(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lhs
 |
 |  rhs
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorRange in module faiss.swigfaiss

class IDSelectorRange(IDSelector)
 |  IDSelectorRange(imin, imax, assume_sorted=False)
 |
 |  ids between [imin, imax)
 |
 |  Method resolution order:
 |      IDSelectorRange
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, imin, imax, assume_sorted=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  find_sorted_ids_bounds(self, list_size, ids, jmin, jmax)
 |      for sorted ids, find the range of list indices where the valid ids are
 |      stored
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorRange(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  assume_sorted
 |      Assume that the ids to handle are sorted. In some cases this can speed
 |      up processing
 |
 |  imax
 |
 |  imin
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorTranslated in module faiss.swigfaiss

class IDSelectorTranslated(IDSelector)
 |  IDSelectorTranslated(*args)
 |
 |  Method resolution order:
 |      IDSelectorTranslated
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorTranslated(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  id_map
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  sel
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IDSelectorXOr in module faiss.swigfaiss

class IDSelectorXOr(IDSelector)
 |  IDSelectorXOr(*args)
 |
 |  does an XOR operation on the two given IDSelector's is_membership
 |  results.
 |
 |  Method resolution order:
 |      IDSelectorXOr
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IDSelectorXOr(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lhs
 |
 |  rhs
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class IOReader in module faiss.swigfaiss

class IOReader(builtins.object)
 |  IOReader(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  filedescriptor(self)
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IOWriter in module faiss.swigfaiss

class IOWriter(builtins.object)
 |  IOWriter(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  filedescriptor(self)
 |
 |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IOWriter(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class ITQMatrix in module faiss.swigfaiss

class ITQMatrix(LinearTransform)
 |  ITQMatrix(d=0)
 |
 |   ITQ implementation from
 |
 |      Iterative quantization: A procrustean approach to learning binary codes
 |      for large-scale image retrieval,
 |
 |  Yunchao Gong, Svetlana Lazebnik, Albert Gordo, Florent Perronnin,
 |  PAMI'12.
 |
 |  Method resolution order:
 |      ITQMatrix
 |      LinearTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, d=0)
 |      both d_in > d_out and d_out < d_in are supported
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x) from faiss.swigfaiss.LinearTransform
 |      works only if is_orthonormal
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ITQMatrix(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  init_rotation
 |
 |  max_iter
 |
 |  seed
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from LinearTransform:
 |
 |  apply_noalloc(self, n, x, xt)
 |      same as apply, but result is pre-allocated
 |
 |  check_identical(self, other)
 |
 |  print_if_verbose(self, name, mat, n, d)
 |
 |  set_is_orthonormal(self)
 |      compute A^T * A to set the is_orthonormal flag
 |
 |  transform_transpose(self, n, y, x)
 |      compute x = A^T * (x - b)
 |      is reverse transform if A has orthonormal lines
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from LinearTransform:
 |
 |  A
 |      Transformation matrix, size d_out * d_in
 |
 |  b
 |      bias vector, size d_out
 |
 |  have_bias
 |
 |  is_orthonormal
 |      whether to use the bias term
 |       check if matrix A is orthonormal (enables reverse_transform)
 |
 |  verbose
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class ITQTransform in module faiss.swigfaiss

class ITQTransform(VectorTransform)
 |  ITQTransform(din=0, dout=0, do_pca_in=False)
 |
 |  The full ITQ transform, including normalizations and PCA transformation
 |
 |  Method resolution order:
 |      ITQTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, din=0, dout=0, do_pca_in=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |       apply the transformation and return the result in a provided matrix
 |      :type n: int
 |      :param n: number of vectors to transform
 |      :type x: float
 |      :param x: input vectors, size n * d_in
 |      :type xt: float
 |      :param xt: output vectors, size n * d_out
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x) from faiss.swigfaiss.VectorTransform
 |      reverse transformation. May not be implemented or may return
 |      approximate result
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ITQTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  do_pca
 |
 |  itq
 |
 |  max_train_per_dim
 |      max training points per dimension
 |
 |  mean
 |
 |  pca_then_itq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class IVFFastScanStats in module faiss.swigfaiss

class IVFFastScanStats(builtins.object)
 |  Methods defined here:
 |
 |  Mcy_at(self, i)
 |
 |  Mcy_reservoir_at(self, i)
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IVFFastScanStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  reservoir_times
 |
 |  t_aq_encode
 |
 |  t_aq_norm_encode
 |
 |  t_compute_distance_tables
 |
 |  t_copy_pack
 |
 |  t_round
 |
 |  t_scan
 |
 |  t_to_flat
 |
 |  thisown
 |      The membership flag
 |
 |  times

Python Library Documentation: class IVFPQSearchParameters in module faiss.swigfaiss

class IVFPQSearchParameters(SearchParametersIVF)
 |  IVFPQSearchParameters(**args)
 |
 |  Method resolution order:
 |      IVFPQSearchParameters
 |      SearchParametersIVF
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IVFPQSearchParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  polysemous_ht
 |      Hamming thresh for polysemous filtering
 |
 |  scan_table_threshold
 |      use table computation or on-the-fly?
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParametersIVF:
 |
 |  ensure_topk_full
 |      For k-NN search, make small early-stop budgets less aggressive:
 |      max_codes is treated as at least k post-IDSelector scans. Supported
 |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
 |      implementations 10 and 11.
 |
 |  inverted_list_context
 |      context object to pass to InvertedLists
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  max_empty_result_buckets
 |      Range-search only: stop after this many consecutive probed lists add
 |      no in-radius results. 0 disables the heuristic. This trades recall
 |      for less work. Supported in parallel_mode 0; FastScan range search
 |      uses implementation 10 for this option.
 |
 |  max_lists_num
 |      FastScan k-NN only: maximum number of inverted lists to visit.
 |      0 means unlimited, i.e. bounded only by nprobe. When set together
 |      with max_codes, either budget may stop the scan. With
 |      ensure_topk_full, this limit is treated as at least k lists.
 |
 |  nprobe
 |      number of probes at query time
 |
 |  quantizer_params
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class IVFRaBitQSearchParameters in module faiss.swigfaiss

class IVFRaBitQSearchParameters(SearchParametersIVF)
 |  IVFRaBitQSearchParameters(**args)
 |
 |  Method resolution order:
 |      IVFRaBitQSearchParameters
 |      SearchParametersIVF
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IVFRaBitQSearchParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centered
 |
 |  qb
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParametersIVF:
 |
 |  ensure_topk_full
 |      For k-NN search, make small early-stop budgets less aggressive:
 |      max_codes is treated as at least k post-IDSelector scans. Supported
 |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
 |      implementations 10 and 11.
 |
 |  inverted_list_context
 |      context object to pass to InvertedLists
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  max_empty_result_buckets
 |      Range-search only: stop after this many consecutive probed lists add
 |      no in-radius results. 0 disables the heuristic. This trades recall
 |      for less work. Supported in parallel_mode 0; FastScan range search
 |      uses implementation 10 for this option.
 |
 |  max_lists_num
 |      FastScan k-NN only: maximum number of inverted lists to visit.
 |      0 means unlimited, i.e. bounded only by nprobe. When set together
 |      with max_codes, either budget may stop the scan. With
 |      ensure_topk_full, this limit is treated as at least k lists.
 |
 |  nprobe
 |      number of probes at query time
 |
 |  quantizer_params
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class IVFSQTurboQSearchParameters in module faiss.swigfaiss

class IVFSQTurboQSearchParameters(SearchParametersIVF)
 |  IVFSQTurboQSearchParameters(**args)
 |
 |   An IVF implementation where the components of the residuals are
 |  encoded with a scalar quantizer. All distance computations
 |  are asymmetric, so the encoded vectors are decoded and approximate
 |  distances are computed.
 |
 |   Search parameters for TurboQuant full types (QT_*_tq).
 |
 |  Method resolution order:
 |      IVFSQTurboQSearchParameters
 |      SearchParametersIVF
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IVFSQTurboQSearchParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  int_qjl
 |      Also use integer popcount for QJL stage (requires qb > 0).
 |
 |  qb
 |      Query quantization bits for integer MSE pre-screening.
 |      0 = float path (default), 1-8 = integer popcount path.
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParametersIVF:
 |
 |  ensure_topk_full
 |      For k-NN search, make small early-stop budgets less aggressive:
 |      max_codes is treated as at least k post-IDSelector scans. Supported
 |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
 |      implementations 10 and 11.
 |
 |  inverted_list_context
 |      context object to pass to InvertedLists
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  max_empty_result_buckets
 |      Range-search only: stop after this many consecutive probed lists add
 |      no in-radius results. 0 disables the heuristic. This trades recall
 |      for less work. Supported in parallel_mode 0; FastScan range search
 |      uses implementation 10 for this option.
 |
 |  max_lists_num
 |      FastScan k-NN only: maximum number of inverted lists to visit.
 |      0 means unlimited, i.e. bounded only by nprobe. When set together
 |      with max_codes, either budget may stop the scan. With
 |      ensure_topk_full, this limit is treated as at least k lists.
 |
 |  nprobe
 |      number of probes at query time
 |
 |  quantizer_params
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class SearchParametersIVF in module faiss.swigfaiss

class SearchParametersIVF(SearchParameters)
 |  SearchParametersIVF(**args)
 |
 |  Method resolution order:
 |      SearchParametersIVF
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParametersIVF(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  ensure_topk_full
 |      For k-NN search, make small early-stop budgets less aggressive:
 |      max_codes is treated as at least k post-IDSelector scans. Supported
 |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
 |      implementations 10 and 11.
 |
 |  inverted_list_context
 |      context object to pass to InvertedLists
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  max_empty_result_buckets
 |      Range-search only: stop after this many consecutive probed lists add
 |      no in-radius results. 0 disables the heuristic. This trades recall
 |      for less work. Supported in parallel_mode 0; FastScan range search
 |      uses implementation 10 for this option.
 |
 |  max_lists_num
 |      FastScan k-NN only: maximum number of inverted lists to visit.
 |      0 means unlimited, i.e. bounded only by nprobe. When set together
 |      with max_codes, either budget may stop the scan. With
 |      ensure_topk_full, this limit is treated as at least k lists.
 |
 |  nprobe
 |      number of probes at query time
 |
 |  quantizer_params
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SearchParameters:
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class IcmEncoder in module faiss.swigfaiss

class IcmEncoder(builtins.object)
 |  IcmEncoder(lsq)
 |
 |  Methods defined here:
 |
 |  __init__(self, lsq)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  encode(self, codes, x, gen, n, ils_iters)
 |       Encode vectors given codebooks
 |
 |      :type codes: int
 |      :param codes:     output codes, size n * M
 |      :type x: float
 |      :param x:         vectors to encode, size n * d
 |      :type gen: std::mt19937
 |      :param gen:       random generator
 |      :type n: int
 |      :param n:         number of vectors
 |      :type ils_iters: int
 |      :param ils_iters: number of iterations of iterative local search
 |
 |  set_binary_term(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IcmEncoder(...)
 |      compute binary terms
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  binaries
 |
 |  lsq
 |
 |  thisown
 |      The membership flag
 |
 |  verbose

Python Library Documentation: class IcmEncoderFactory in module faiss.swigfaiss

class IcmEncoderFactory(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get(self, lsq)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IcmEncoderFactory(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Index in module faiss.swigfaiss

class Index(builtins.object)
 |  Index(*args, **kwargs)
 |
 |   Abstract structure for an index, supports adding vectors and searching
 |  them.
 |
 |  All vectors provided at add or search time are 32-bit float arrays,
 |  although the internal representation may vary.
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |       Add n vectors of dimension d to the index.
 |
 |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
 |      This function slices the input vectors in chunks smaller than
 |      blocksize_add and calls add_core.
 |      :type n: int
 |      :param n:      number of vectors
 |      :type x: float
 |      :param x:      input matrix, size n * d
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return at most k vectors. If there are not enough results for a
 |      query, the result array is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Index(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  thisown
 |      The membership flag
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class Index2Layer in module faiss.swigfaiss

class Index2Layer(IndexFlatCodes)
 |  Index2Layer(*args)
 |
 |   Same as an IndexIVFPQ without the inverted lists: codes are stored
 |  sequentially
 |
 |  The class is mainly intended to store encoded vectors that can be
 |  accessed randomly, the search function is not implemented.
 |
 |  Method resolution order:
 |      Index2Layer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      not implemented
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  transfer_to_IVFPQ(self, other)
 |      transfer the flat codes to an IVFPQ index
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Index2Layer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  code_size_1
 |      size of the code for the first level (ceil(log8(q1.nlist)))
 |
 |  code_size_2
 |      size of the code for the second level
 |
 |  pq
 |      second level quantizer is always a PQ
 |
 |  q1
 |      first level quantizer
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexAdditiveQuantizer in module faiss.swigfaiss

class IndexAdditiveQuantizer(IndexFlatCodes)
 |  IndexAdditiveQuantizer(*args)
 |
 |  Abstract class for additive quantizers. The search functions are in common.
 |
 |  Method resolution order:
 |      IndexAdditiveQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexAdditiveQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  aq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexAdditiveQuantizerFastScan in module faiss.swigfaiss

class IndexAdditiveQuantizerFastScan(IndexFastScan)
 |  IndexAdditiveQuantizerFastScan(*args)
 |
 |   Fast scan version of IndexAQ. Works for 4-bit AQ for now.
 |
 |  The codes are not stored sequentially but grouped in blocks of size bbs.
 |  This makes it possible to compute distances quickly with SIMD instructions.
 |
 |  Implementations:
 |  12: blocked loop with internal loop on Q with qbs
 |  13: same with reservoir accumulator to store results
 |  14: no qbs with heap accumulator
 |  15: no qbs with reservoir accumulator
 |
 |  Method resolution order:
 |      IndexAdditiveQuantizerFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      build from an existing IndexAQ
 |
 |      |
 |
 |      *Overload 2:*
 |      build from an existing IndexAQ
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFastScan
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, *args)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFastScan
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFastScan
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors.
 |
 |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
 |             contiguous. But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.IndexFastScan
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexAdditiveQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinary in module faiss.swigfaiss

class IndexBinary(builtins.object)
 |  IndexBinary(*args, **kwargs)
 |
 |   Abstract structure for a binary index.
 |
 |  Supports adding vertices and searching them.
 |
 |  All queries are symmetric because there is no distinction between codes and
 |  vectors.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |       Add n vectors of dimension d to the index.
 |
 |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
 |      :type x: uint8_t
 |      :param x:      input matrix, size n * d / 8
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return at most k vectors. If there are not enough results for a
 |      query, the result array is padded with -1s.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type distances: int
 |      :param distances:   output pairwise distances, size n*k
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: uint8_t
 |      :param x:      training vectors, size n * d / 8
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinary(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  thisown
 |      The membership flag
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryFlat in module faiss.swigfaiss

class IndexBinaryFlat(IndexBinary)
 |  IndexBinaryFlat(*args)
 |
 |  Index that stores the full vectors and performs exhaustive search.
 |
 |  Method resolution order:
 |      IndexBinaryFlat
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       Remove some ids. Note that because of the indexing structure,
 |      the semantics of this operation are different from the usual ones:
 |      the new ids are shifted.
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  approx_topk_mode
 |
 |  query_batch_size
 |
 |  thisown
 |      The membership flag
 |
 |  use_heap
 |       Select between using a heap or counting to select the k smallest values
 |      when scanning inverted lists.
 |
 |  xb
 |      database vectors, size ntotal * d / 8
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: uint8_t
 |      :param x:      training vectors, size n * d / 8
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryFromFloat in module faiss.swigfaiss

class IndexBinaryFromFloat(IndexBinary)
 |  IndexBinaryFromFloat(*args)
 |
 |   IndexBinary backed by a float Index.
 |
 |  Supports adding vertices and searching them.
 |
 |  All queries are symmetric because there is no distinction between codes and
 |  vectors.
 |
 |  Method resolution order:
 |      IndexBinaryFromFloat
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryFromFloat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  index
 |
 |  own_fields
 |      Whether object owns the index pointer.
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryHNSW in module faiss.swigfaiss

class IndexBinaryHNSW(IndexBinary)
 |  IndexBinaryHNSW(*args)
 |
 |   The HNSW index is a normal random-access index with a HNSW
 |  link structure built on top
 |
 |  Method resolution order:
 |      IndexBinaryHNSW
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  get_distance_computer(self)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryHNSW(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryHNSWCagra in module faiss.swigfaiss

class IndexBinaryHNSWCagra(IndexBinaryHNSW)
 |  IndexBinaryHNSWCagra(*args)
 |
 |  Method resolution order:
 |      IndexBinaryHNSWCagra
 |      IndexBinaryHNSW
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryHNSWCagra(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  base_level_only
 |      When set to true, the index is immutable.
 |      This option is used to copy the knn graph from GpuIndexBinaryCagra
 |      to the base level of IndexBinaryHNSWCagra without adding upper levels.
 |      Doing so enables to search the HNSW index, but removes the
 |      ability to add vectors.
 |
 |  num_base_level_search_entrypoints
 |      When `base_level_only` is set to `True`, the search function
 |      searches only the base level knn graph of the HNSW index.
 |      This parameter selects the entry point by randomly selecting
 |      some points and using the best one.
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinaryHNSW:
 |
 |  get_distance_computer(self)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinaryHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryHash in module faiss.swigfaiss

class IndexBinaryHash(IndexBinary)
 |  IndexBinaryHash(*args)
 |
 |  just uses the b first bits as a hash value
 |
 |  Method resolution order:
 |      IndexBinaryHash
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  hashtable_size(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryHash(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  b
 |
 |  invlists
 |
 |  nflip
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: uint8_t
 |      :param x:      training vectors, size n * d / 8
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryHashStats in module faiss.swigfaiss

class IndexBinaryHashStats(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryHashStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n0
 |
 |  ndis
 |
 |  nlist
 |
 |  nq
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IndexBinaryIDMap in module faiss.swigfaiss

class IndexBinaryIDMap(IndexBinary)
 |  IndexBinaryIDMap(*args)
 |
 |  Index that translates search results to ids
 |
 |  Method resolution order:
 |      IndexBinaryIDMap
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |      this will fail. Use add_with_ids
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, x, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      remove ids adapted to IndexFlat
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryIDMap(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  id_map
 |      whether pointers are deleted in destructor
 |
 |  index
 |
 |  own_fields
 |      the sub-index
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryIDMap2 in module faiss.swigfaiss

class IndexBinaryIDMap2(IndexBinaryIDMap)
 |  IndexBinaryIDMap2(*args)
 |
 |  same as IndexIDMap but also provides an efficient reconstruction
 |  implementation via a 2-way index
 |
 |  Method resolution order:
 |      IndexBinaryIDMap2
 |      IndexBinaryIDMap
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_consistency(self)
 |      check that the rev_map and the id_map are in sync
 |
 |  construct_rev_map(self)
 |      make the rev_map from scratch
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryIDMap2(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rev_map
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinaryIDMap:
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |      this will fail. Use add_with_ids
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, x, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinaryIDMap:
 |
 |  id_map
 |      whether pointers are deleted in destructor
 |
 |  index
 |
 |  own_fields
 |      the sub-index
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryIVF in module faiss.swigfaiss

class IndexBinaryIVF(IndexBinary)
 |  IndexBinaryIVF(*args)
 |
 |   Index based on a inverted file (IVF)
 |
 |  In the inverted file, the quantizer (an IndexBinary instance) provides a
 |  quantization index for each vector to be added. The quantization
 |  index maps to a list (aka inverted list or posting list), where the
 |  id of the vector is stored.
 |
 |  Otherwise the object is similar to the IndexIVF
 |
 |  Method resolution order:
 |      IndexBinaryIVF
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  add_core(self, n, x, xids, precomputed_idx)
 |       Implementation of vector addition where the vector assignments are
 |      predefined.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_InvertedListScanner(self, store_pairs=False)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, other, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_preassigned_c = range_search_preassigned(self, n, x, radius, assign, centroid_dis, result)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: uint8_t
 |      :param recons: output array of reconstructed vectors, size ni * d / 8
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d / 8)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None)
 |       Search a set of vectors, that are pre-quantized by the IVF
 |       quantizer. Fill in the corresponding heaps with the query
 |       results. search() calls this.
 |
 |      :type n: int
 |      :param n:      nb of vectors to query
 |      :type x: uint8_t
 |      :param x:      query vectors, size nx * d
 |      :type assign: int
 |      :param assign: coarse quantization indices, size nx * nprobe
 |      :type centroid_dis: int
 |      :param centroid_dis:
 |                        distances to coarse centroids, size nx * nprobe
 |      :param distance:
 |                        output distances, size n * k
 |      :type labels: int
 |      :param labels: output labels, size n * k
 |      :type store_pairs: boolean
 |      :param store_pairs: store inv list index + inv list offset
 |                              instead in upper/lower 32 bit of result,
 |                              instead of ids (used for reranking).
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params: used to override the object's search parameters
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryIVF(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  direct_map
 |      map for direct access to the elements. Enables reconstruct().
 |
 |  invlists
 |      Access to the actual data
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nlist
 |      number of possible key values
 |
 |  nprobe
 |      number of probes at query time
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  own_invlists
 |
 |  per_invlist_search
 |      collect computations per batch
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  thisown
 |      The membership flag
 |
 |  use_heap
 |       Select between using a heap or counting to select the k smallest values
 |      when scanning inverted lists.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryMultiHash in module faiss.swigfaiss

class IndexBinaryMultiHash(IndexBinary)
 |  IndexBinaryMultiHash(*args)
 |
 |  just uses the b first bits as a hash value
 |
 |  Method resolution order:
 |      IndexBinaryMultiHash
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |
 |  hashtable_size(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reset(self)
 |      Removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryMultiHash(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  b
 |      nb bits per hash map
 |
 |  maps
 |
 |  nflip
 |      nb bit flips to use at search time
 |
 |  nhash
 |      nb of hash maps
 |
 |  own_fields
 |
 |  storage
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: uint8_t
 |      :param x:      training vectors, size n * d / 8
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryReplicas in module faiss.swigfaiss

class IndexBinaryReplicas(ThreadedIndexBaseBinary)
 |  IndexBinaryReplicas(*args)
 |
 |  Takes individual faiss::Index instances, and splits queries for
 |  sending to each Index instance, and joins the results together
 |  when done.
 |  Each index is managed by a separate CPU thread.
 |
 |  Method resolution order:
 |      IndexBinaryReplicas
 |      ThreadedIndexBaseBinary
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      The dimension that all sub-indices must share will be the dimension of
 |      the first sub-index added
 |      :type threaded: boolean, optional
 |      :param threaded: do we use one thread per sub-index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 2:*
 |      :type d: int
 |      :param d: the dimension that all sub-indices must share
 |      :type threaded: boolean, optional
 |      :param threaded: do we use one thread per sub index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 3:*
 |      :type d: int
 |      :param d: the dimension that all sub-indices must share
 |      :param threaded: do we use one thread per sub index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 4:*
 |      int version due to the implicit bool conversion ambiguity of int as
 |      dimension
 |
 |      |
 |
 |      *Overload 5:*
 |      int version due to the implicit bool conversion ambiguity of int as
 |      dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  addIndex = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  add_c = add(self, n, x)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  add_replica(self, index)
 |      Alias for addIndex()
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, arg2, v)
 |      reconstructs from the first index
 |
 |  remove_replica(self, index)
 |      Alias for removeIndex()
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      faiss::Index API
 |      Query is partitioned into a slice for each sub-index
 |      split by ceil(n / #indices) for our sub-indices
 |
 |  syncWithSubIndexes(self)
 |      Synchronize the top-level index (IndexShards) with data in the
 |      sub-indices
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryReplicas(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ThreadedIndexBaseBinary:
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ThreadedIndexBaseBinary:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexBinaryShards in module faiss.swigfaiss

class IndexBinaryShards(ThreadedIndexBaseBinary)
 |  IndexBinaryShards(*args)
 |
 |  Index that concatenates the results from several sub-indexes
 |
 |  Method resolution order:
 |      IndexBinaryShards
 |      ThreadedIndexBaseBinary
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |
 |      The dimension that all sub-indices must share will be the dimension of
 |      the first sub-index added
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :type successive_ids: boolean, optional
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 2:*
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :type successive_ids: boolean, optional
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 3:*
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 4:*
 |
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 5:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |      |
 |
 |      *Overload 6:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |      |
 |
 |      *Overload 7:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |      supported only for sub-indices that implement add_with_ids
 |
 |  add_shard = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      Cases (successive_ids, xids):
 |      - true, non-NULL       ERROR: it makes no sense to pass in ids and
 |                             request them to be shifted
 |      - true, NULL           OK: but should be called only once (calls add()
 |                             on sub-indexes).
 |      - false, non-NULL      OK: will call add_with_ids with passed in xids
 |                             distributed evenly over shards
 |      - false, NULL          OK: will call add_with_ids on each sub-index,
 |                             starting at ntotal
 |
 |  remove_shard(self, index)
 |      Alias for removeIndex()
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  syncWithSubIndexes(self)
 |      Synchronize the top-level index (IndexShards) with data in the
 |      sub-indices
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexBinaryShards(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  successive_ids
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ThreadedIndexBaseBinary:
 |
 |  addIndex(self, index)
 |      override an index that is managed by ourselves.
 |      WARNING: once an index is added, it becomes unsafe to touch it from any
 |      other thread than that on which is managing it, until we are shut
 |      down. Use runOnIndex to perform work on it instead.
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ThreadedIndexBaseBinary:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFastScan in module faiss.swigfaiss

class IndexFastScan(Index)
 |  IndexFastScan(*args, **kwargs)
 |
 |   Fast scan version of IndexPQ and IndexAQ. Works for 4-bit PQ and AQ for now.
 |
 |  The codes are not stored sequentially but grouped in blocks of size bbs.
 |  This makes it possible to compute distances quickly with SIMD instructions.
 |  The trailing codes (padding codes that are added to complete the last code)
 |  are garbage.
 |
 |  Implementations:
 |  12: blocked loop with internal loop on Q with qbs
 |  13: same with reservoir accumulator to store results
 |  14: no qbs with heap accumulator
 |  15: no qbs with reservoir accumulator
 |
 |  Method resolution order:
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  fast_scan_code_size(self)
 |       Get the size of the code portion packed by pq4_pack_codes.
 |
 |      Returns the number of bytes per vector that are interleaved into
 |      SIMD blocks by pq4_pack_codes, excluding any embedded metadata
 |      (e.g., RaBitQ factors). The meaning of these bytes depends on the
 |      quantizer: for PQ/AQ they are 4-bit sub-quantizer nibbles, for
 |      RaBitQ they are 1-bit-per-dimension sign bits packed into nibbles.
 |
 |      Must be implemented by all derived classes.
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search for k nearest neighbors
 |
 |      :type n: int
 |      :param n:          number of query vectors
 |      :type x: float
 |      :param x:          query vectors (n * d)
 |      :type k: int
 |      :param k:          number of nearest neighbors to find
 |      :type distances: float
 |      :param distances:  output distances (n * k)
 |      :type labels: int
 |      :param labels:     output labels/indices (n * k)
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:     optional search parameters
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlat in module faiss.swigfaiss

class IndexFlat(IndexFlatCodes)
 |  IndexFlat(*args)
 |
 |  Index that stores the full vectors and performs exhaustive search
 |
 |  Method resolution order:
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_xb(self, *args)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlat1D in module faiss.swigfaiss

class IndexFlat1D(IndexFlatL2)
 |  IndexFlat1D(continuous_update=True)
 |
 |  optimized version for 1D "vectors".
 |
 |  Method resolution order:
 |      IndexFlat1D
 |      IndexFlatL2
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, continuous_update=True)
 |      :param d: dimensionality of the input vectors
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      Warn: the distances returned are L1 not L2
 |
 |  update_permutation(self)
 |      if not continuous_update, call this between the last add and
 |      the first search
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlat1D(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  continuous_update
 |      is the permutation updated continuously?
 |
 |  perm
 |      sorted database indices
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatL2:
 |
 |  clear_l2norms(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  sync_l2norms(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatL2:
 |
 |  cached_l2norms
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlat:
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_xb(self, *args)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlatCodes in module faiss.swigfaiss

class IndexFlatCodes(Index)
 |  IndexFlatCodes(*args)
 |
 |   Index that encodes all vectors as fixed-size codes (size code_size). Storage
 |  is in the codes vector
 |
 |  Method resolution order:
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search implemented by decoding (most index types will have a faster
 |      implementation)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlatCodes(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlatIP in module faiss.swigfaiss

class IndexFlatIP(IndexFlat)
 |  IndexFlatIP(*args)
 |
 |  Method resolution order:
 |      IndexFlatIP
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlatIP(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlat:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_xb(self, *args)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlatIPPanorama in module faiss.swigfaiss

class IndexFlatIPPanorama(IndexFlatPanorama)
 |  IndexFlatIPPanorama(d_in, n_levels_in, batch_size_in=512)
 |
 |  Method resolution order:
 |      IndexFlatIPPanorama
 |      IndexFlatPanorama
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, d_in, n_levels_in, batch_size_in=512)
 |      :param d: dimensionality of the input vectors
 |      :param n_levels: number of Panorama levels
 |      :param batch_size: batch size for Panorama storage
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes_in, xids) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i, n, recons) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlatIPPanorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatPanorama:
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexFlatPanorama:
 |
 |  batch_size
 |
 |  n_levels
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatPanorama:
 |
 |  cum_sums
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlat:
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_xb(self, *args)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlatL2 in module faiss.swigfaiss

class IndexFlatL2(IndexFlat)
 |  IndexFlatL2(*args)
 |
 |  Method resolution order:
 |      IndexFlatL2
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      :param d: dimensionality of the input vectors
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  clear_l2norms(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  sync_l2norms(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlatL2(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  cached_l2norms
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlat:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_xb(self, *args)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlatL2Panorama in module faiss.swigfaiss

class IndexFlatL2Panorama(IndexFlatPanorama)
 |  IndexFlatL2Panorama(d_in, n_levels_in, batch_size_in=512)
 |
 |  Method resolution order:
 |      IndexFlatL2Panorama
 |      IndexFlatPanorama
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, d_in, n_levels_in, batch_size_in=512)
 |      :param d: dimensionality of the input vectors
 |      :param n_levels: number of Panorama levels
 |      :param batch_size: batch size for Panorama storage
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes_in, xids) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i, n, recons) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None) from faiss.swigfaiss.IndexFlatPanorama
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlatL2Panorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatPanorama:
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexFlatPanorama:
 |
 |  batch_size
 |
 |  n_levels
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatPanorama:
 |
 |  cum_sums
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlat:
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_xb(self, *args)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexFlatPanorama in module faiss.swigfaiss

class IndexFlatPanorama(IndexFlat)
 |  IndexFlatPanorama(d_in, metric, n_levels_in, batch_size_in)
 |
 |  Method resolution order:
 |      IndexFlatPanorama
 |      IndexFlat
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, d_in, metric, n_levels_in, batch_size_in)
 |      :param d: dimensionality of the input vectors
 |      :type metric: int
 |      :param metric: metric type
 |      :param n_levels: number of Panorama levels
 |      :param batch_size: batch size for Panorama storage
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes_in, xids)
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i, n, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexFlatPanorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  batch_size
 |
 |  n_levels
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  cum_sums
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlat:
 |
 |  compute_distance_subset(self, n, x, k, distances, labels)
 |       compute distance with a subset of vectors
 |
 |      :type x: float
 |      :param x:       query vectors, size n * d
 |      :type labels: int
 |      :param labels:  indices of the vectors that should be compared
 |                         for each query vector, size n * k
 |      :type distances: float
 |      :param distances:
 |                         corresponding output distances, size n * k
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_xb(self, *args)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSW in module faiss.swigfaiss

class IndexHNSW(Index)
 |  IndexHNSW(*args)
 |
 |   The HNSW index is a normal random-access index with a HNSW
 |  link structure built on top
 |
 |  Method resolution order:
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Adds vectors to the index. May not be called concurrently.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSW(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  thisown
 |      The membership flag
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSW2Level in module faiss.swigfaiss

class IndexHNSW2Level(IndexHNSW)
 |  IndexHNSW2Level(*args)
 |
 |  2-level code structure with fast random access
 |
 |  Method resolution order:
 |      IndexHNSW2Level
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  flip_to_ivf(self)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSW2Level(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexHNSW:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Adds vectors to the index. May not be called concurrently.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSWCagra in module faiss.swigfaiss

class IndexHNSWCagra(IndexHNSW)
 |  IndexHNSWCagra(*args)
 |
 |  Method resolution order:
 |      IndexHNSWCagra
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  get_numeric_type(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  set_numeric_type(self, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSWCagra(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  base_level_only
 |      When set to true, the index is immutable.
 |      This option is used to copy the knn graph from GpuIndexCagra
 |      to the base level of IndexHNSWCagra without adding upper levels.
 |      Doing so enables to search the HNSW index, but removes the
 |      ability to add vectors.
 |
 |  num_base_level_search_entrypoints
 |      When `base_level_only` is set to `True`, the search function
 |      searches only the base level knn graph of the HNSW index.
 |      This parameter selects the entry point by randomly selecting
 |      some points and using the best one.
 |
 |  numeric_type_
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexHNSW:
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSWFlat in module faiss.swigfaiss

class IndexHNSWFlat(IndexHNSW)
 |  IndexHNSWFlat(*args)
 |
 |  Flat index topped with with a HNSW structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexHNSWFlat
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSWFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexHNSW:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Adds vectors to the index. May not be called concurrently.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSWFlatPanorama in module faiss.swigfaiss

class IndexHNSWFlatPanorama(IndexHNSWFlat)
 |  IndexHNSWFlatPanorama(*args)
 |
 |   Panorama implementation of IndexHNSWFlat following
 |  https://www.arxiv.org/pdf/2510.00566.
 |
 |  Unlike cluster-based Panorama, the vectors have to be higher dimensional
 |  (i.e. typically d > 512) and/or be able to compress a lot of their energy in
 |  the early dimensions to be effective. This is because HNSW accesses vectors
 |  in a random order, which makes cache misses dominate the distance computation
 |  time.
 |
 |  The `num_panorama_levels` parameter controls the granularity of progressive
 |  distance refinement, allowing candidates to be eliminated early using partial
 |  distance computations rather than computing full distances.
 |
 |  NOTE: This version of HNSW handles search slightly differently than the
 |  vanilla HNSW, as it uses partial distance computations with progressive
 |  refinement bounds. Instead of computing full distances immediately for all
 |  candidates, Panorama maintains lower and upper bounds that are incrementally
 |  tightened across refinement levels. Candidates are inserted into the search
 |  beam using approximate distance estimates (LB+UB)/2 and are only fully
 |  evaluated when they survive pruning and enter the result heap. This allows
 |  the algorithm to prune unpromising candidates early using Cauchy-Schwarz
 |  bounds on partial inner products. Hence, recall is not guaranteed to be the
 |  same as vanilla HNSW due to the heterogeneous precision within the search
 |  beam (exact vs. partial distance estimates affecting traversal order).
 |
 |  Method resolution order:
 |      IndexHNSWFlatPanorama
 |      IndexHNSWFlat
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  get_cum_sum(self, i)
 |      Inline for performance - called frequently in search hot path.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSWFlatPanorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  num_panorama_levels
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  cum_sums
 |
 |  pano
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexHNSW:
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSWPQ in module faiss.swigfaiss

class IndexHNSWPQ(IndexHNSW)
 |  IndexHNSWPQ(*args)
 |
 |  PQ index topped with with a HNSW structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexHNSWPQ
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSWPQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexHNSW:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Adds vectors to the index. May not be called concurrently.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexHNSWSQ in module faiss.swigfaiss

class IndexHNSWSQ(IndexHNSW)
 |  IndexHNSWSQ(*args)
 |
 |  SQ index topped with a HNSW structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexHNSWSQ
 |      IndexHNSW
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexHNSWSQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexHNSW:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Adds vectors to the index. May not be called concurrently.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  init_level_0_from_entry_points(self, npt, points, nearests)
 |      alternative graph building
 |
 |  init_level_0_from_knngraph(self, k, D, I)
 |      alternative graph building
 |
 |  link_singletons(self)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reorder_links(self)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
 |       Perform search only on level 0, given the starting points for
 |      each vertex.
 |
 |      :type search_type: int, optional
 |      :param search_type: 1:perform one search per nprobe, 2: enqueue
 |                             all entry points
 |
 |  shrink_level_0_neighbors(self, size)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexHNSW:
 |
 |  hnsw
 |
 |  init_level0
 |
 |  keep_max_size_level0
 |
 |  own_fields
 |
 |  retain_locks
 |
 |  storage
 |
 |  use_visited_hashset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexIDMap in module faiss.swigfaiss

class IndexIDMap(Index)
 |  IndexIDMap(*args)
 |
 |  Index that translates search results to ids
 |
 |  Method resolution order:
 |      IndexIDMap
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      this will fail. Use add_with_ids
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      remove ids adapted to IndexFlat
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIDMap(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  id_map
 |      whether pointers are deleted in destructor
 |
 |  index
 |
 |  own_fields
 |      the sub-index
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexIDMap2 in module faiss.swigfaiss

class IndexIDMap2(IndexIDMap)
 |  IndexIDMap2(*args)
 |
 |  same as IndexIDMap but also provides an efficient reconstruction
 |  implementation via a 2-way index
 |
 |  Method resolution order:
 |      IndexIDMap2
 |      IndexIDMap
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_consistency(self)
 |      check that the rev_map and the id_map are in sync
 |
 |  construct_rev_map(self)
 |      make the rev_map from scratch
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIDMap2(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rev_map
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIDMap:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      this will fail. Use add_with_ids
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIDMap:
 |
 |  id_map
 |      whether pointers are deleted in destructor
 |
 |  index
 |
 |  own_fields
 |      the sub-index
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexIVF in module faiss.swigfaiss

class IndexIVF(Index, IndexIVFInterface)
 |  IndexIVF(*args, **kwargs)
 |
 |   Index based on a inverted file (IVF)
 |
 |  In the inverted file, the quantizer (an Index instance) provides a
 |  quantization index for each vector to be added. The quantization
 |  index maps to a list (aka inverted list or posting list), where the
 |  id of the vector is stored.
 |
 |  The inverted list object is required only after training. If none is
 |  set externally, an ArrayInvertedLists is used automatically.
 |
 |  At search time, the vector to be searched is also quantized, and
 |  only the list corresponding to the quantization index is
 |  searched. This speeds up the search by making it
 |  non-exhaustive. This can be relaxed using multi-probe search: a few
 |  (nprobe) quantization indices are selected and several inverted
 |  lists are visited.
 |
 |  Sub-classes implement a post-filtering of the index that refines
 |  the distance estimation from the query to database vectors.
 |
 |  Method resolution order:
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_CodePacker(self)
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVF(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFAdditiveQuantizer in module faiss.swigfaiss

class IndexIVFAdditiveQuantizer(IndexIVF)
 |  IndexIVFAdditiveQuantizer(*args)
 |
 |  Abstract class for IVF additive quantizers.
 |  The search functions are in common.
 |
 |  Method resolution order:
 |      IndexIVFAdditiveQuantizer
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFAdditiveQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  aq
 |
 |  thisown
 |      The membership flag
 |
 |  use_precomputed_table
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFAdditiveQuantizerFastScan in module faiss.swigfaiss

class IndexIVFAdditiveQuantizerFastScan(IndexIVFFastScan)
 |  IndexIVFAdditiveQuantizerFastScan(*args)
 |
 |   Fast scan version of IVFAQ. Works for 4-bit AQ for now.
 |
 |  The codes in the inverted lists are not stored sequentially but
 |  grouped in blocks of size bbs. This makes it possible to very quickly
 |  compute distances with SIMD instructions.
 |
 |  Implementations (implem):
 |  0: auto-select implementation (default)
 |  1: orig's search, re-implemented
 |  2: orig's search, re-ordered by invlist
 |  10: optimizer int16 search, collect results in heap, no qbs
 |  11: idem, collect results in reservoir
 |  12: optimizer int16 search, collect results in heap, uses qbs
 |  13: idem, collect results in reservoir
 |
 |  Method resolution order:
 |      IndexIVFAdditiveQuantizerFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.IndexIVFFastScan
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |      same as the regular IVFAQ encoder. The codes are not reorganized by
 |      blocks a that point
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, aq, nlist, metric, bbs, own_invlists)
 |
 |  lookup_table_is_3d(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.IndexIVFFastScan
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFAdditiveQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFFastScan in module faiss.swigfaiss

class IndexIVFFastScan(IndexIVF)
 |  IndexIVFFastScan(*args, **kwargs)
 |
 |   Fast scan version of IVFPQ and IVFAQ. Works for 4-bit PQ/AQ for now.
 |
 |  The codes in the inverted lists are not stored sequentially but
 |  grouped in blocks of size bbs. This makes it possible to very quickly
 |  compute distances with SIMD instructions.
 |
 |  Implementations (implem):
 |  0: auto-select implementation (default)
 |  1: orig's search, re-implemented
 |  2: orig's search, re-ordered by invlist
 |  10: optimizer int16 search, collect results in heap, no qbs
 |  11: idem, collect results in reservoir
 |  12: optimizer int16 search, collect results in heap, uses qbs
 |  13: idem, collect results in reservoir
 |  14: internally multithreaded implem over nq * nprobe
 |  15: same with reservoir
 |
 |  For range search, only 10 and 12 are supported.
 |  add 100 to the implem to force single-thread scanning (the coarse quantizer
 |  may still use multiple threads).
 |
 |  Method resolution order:
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  fast_scan_code_size(self)
 |       Get the size of the code portion packed by pq4_pack_codes.
 |
 |      Returns the number of bytes per vector that are interleaved into
 |      SIMD blocks by pq4_pack_codes, excluding any embedded metadata
 |      (e.g., RaBitQ factors). The meaning of these bytes depends on the
 |      quantizer: for PQ/AQ they are 4-bit sub-quantizer nibbles, for
 |      RaBitQ they are 1-bit-per-dimension sign bits packed into nibbles.
 |
 |      Must be implemented by all derived classes.
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  lookup_table_is_3d(self)
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search for k nearest neighbors
 |
 |      :type n: int
 |      :param n:          number of query vectors
 |      :type x: float
 |      :param x:          query vectors (n * d)
 |      :type k: int
 |      :param k:          number of nearest neighbors to find
 |      :type distances: float
 |      :param distances:  output distances (n * k)
 |      :type labels: int
 |      :param labels:     output labels/indices (n * k)
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:     optional search parameters
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFFlat in module faiss.swigfaiss

class IndexIVFFlat(IndexIVF)
 |  IndexIVFFlat(*args)
 |
 |   Inverted file with stored vectors. Here the inverted file
 |  pre-selects the vectors to be searched, but they are not otherwise
 |  encoded, the code array just contains the raw float entries.
 |
 |  Method resolution order:
 |      IndexIVFFlat
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFFlatDedup in module faiss.swigfaiss

class IndexIVFFlatDedup(IndexIVFFlat)
 |  IndexIVFFlatDedup(*args)
 |
 |  Method resolution order:
 |      IndexIVFFlatDedup
 |      IndexIVFFlat
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      implemented for all IndexIVF* classes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |      not implemented
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |      not implemented
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      also dedups the training set
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |      not implemented
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFFlatDedup(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFlat:
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  set_direct_map_type(self, type)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFFlatPanorama in module faiss.swigfaiss

class IndexIVFFlatPanorama(IndexIVFFlat)
 |  IndexIVFFlatPanorama(*args)
 |
 |  Panorama adaptation of IndexIVFFlat following
 |  https://www.arxiv.org/pdf/2510.00566.
 |
 |  IDEA:
 |  Panorama adapts the storage layout within each cluster and uses
 |  pruning with bounds to improve the search performance.
 |  Combined with orthogonal transforms upstream that concentrate the energy
 |  in the early dimensions (like PCA, Cayley, etc.), Panorama can prune up
 |  to 95% of the vectors in the cluster.
 |
 |  OVERHEAD:
 |  To be more efficient, we compute the residual energies at insertion time
 |  and store them along the vectors, which comes with an additional storage
 |  overhead of exactly (nlevels + 1) floats per vector. Add time is also
 |  slightly higher due to the overhead of transposing the vectors.
 |
 |  NOTE:
 |  We inherit from IndexIVFFlat instead of IndexIVF so we can keep the same
 |  insertion logic. The code responsible for level-oriented storage is in
 |  `ArrayInvertedListsPanorama`, which is a struct member of `IndexIVF`.
 |
 |  Method resolution order:
 |      IndexIVFFlatPanorama
 |      IndexIVFFlat
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFFlatPanorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  batch_size
 |
 |  cum_sums
 |
 |  n_levels
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFlat:
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFIndependentQuantizer in module faiss.swigfaiss

class IndexIVFIndependentQuantizer(Index)
 |  IndexIVFIndependentQuantizer(*args)
 |
 |   An IVF index with a quantizer that has a different input dimension from the
 |  payload size. The vectors to encode are obtained from the input vectors by a
 |  VectorTransform.
 |
 |  Method resolution order:
 |      IndexIVFIndependentQuantizer
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFIndependentQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  index_ivf
 |      the IVF index, controls nlist and nprobe
 |
 |  own_fields
 |      whether *this owns the 3 fields
 |
 |  quantizer
 |      quantizer is fed directly with the input vectors
 |
 |  thisown
 |      The membership flag
 |
 |  vt
 |      transform before the IVF vectors are applied
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexIVFInterface in module faiss.swigfaiss

class IndexIVFInterface(Level1Quantizer)
 |  IndexIVFInterface(*args, **kwargs)
 |
 |  Method resolution order:
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |       Range search a set of vectors, that are pre-quantized by the IVF
 |       quantizer. Fill in the RangeSearchResults results. The default
 |      implementation uses InvertedListScanners to do the search.
 |
 |      :param n:      nb of vectors to query
 |      :type x: float
 |      :param x:      query vectors, size nx * d
 |      :param assign: coarse quantization indices, size nx * nprobe
 |      :param centroid_dis:
 |                        distances to coarse centroids, size nx * nprobe
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result: Output results
 |      :type store_pairs: boolean, optional
 |      :param store_pairs: store inv list index + inv list offset
 |                              instead in upper/lower 32 bit of result,
 |                              instead of ids (used for reranking).
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params: used to override the object's search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:  search stats to be updated (can be null)
 |
 |  search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |       search a set of vectors, that are pre-quantized by the IVF
 |       quantizer. Fill in the corresponding heaps with the query
 |       results. The default implementation uses InvertedListScanners
 |       to do the search.
 |
 |      :type n: int
 |      :param n:      nb of vectors to query
 |      :type x: float
 |      :param x:      query vectors, size nx * d
 |      :type assign: int
 |      :param assign: coarse quantization indices, size nx * nprobe
 |      :type centroid_dis: float
 |      :param centroid_dis:
 |                        distances to coarse centroids, size nx * nprobe
 |      :param distance:
 |                        output distances, size n * k
 |      :type labels: int
 |      :param labels: output labels, size n * k
 |      :type store_pairs: boolean
 |      :param store_pairs: store inv list index + inv list offset
 |                              instead in upper/lower 32 bit of result,
 |                              instead of ids (used for reranking).
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params: used to override the object's search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:  search stats to be updated (can be null)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFInterface(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFLocalSearchQuantizer in module faiss.swigfaiss

class IndexIVFLocalSearchQuantizer(IndexIVFAdditiveQuantizer)
 |  IndexIVFLocalSearchQuantizer(*args)
 |
 |   IndexIVF based on a residual quantizer. Stored vectors are
 |  approximated by residual quantization codes.
 |
 |  Method resolution order:
 |      IndexIVFLocalSearchQuantizer
 |      IndexIVFAdditiveQuantizer
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFLocalSearchQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lsq
 |      The LSQ quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizer:
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
 |
 |  aq
 |
 |  use_precomputed_table
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFLocalSearchQuantizerFastScan in module faiss.swigfaiss

class IndexIVFLocalSearchQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
 |  IndexIVFLocalSearchQuantizerFastScan(*args)
 |
 |  Method resolution order:
 |      IndexIVFLocalSearchQuantizerFastScan
 |      IndexIVFAdditiveQuantizerFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFLocalSearchQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lsq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.IndexIVFFastScan
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |      same as the regular IVFAQ encoder. The codes are not reorganized by
 |      blocks a that point
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, aq, nlist, metric, bbs, own_invlists)
 |
 |  lookup_table_is_3d(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.IndexIVFFastScan
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFPQ in module faiss.swigfaiss

class IndexIVFPQ(IndexIVF)
 |  IndexIVFPQ(*args)
 |
 |   Inverted file with Product Quantizer encoding. Each residual
 |  vector is encoded as a product quantizer code.
 |
 |  Method resolution order:
 |      IndexIVFPQ
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_core_o(self, n, x, xids, residuals_2, precomputed_idx=None, inverted_list_context=None)
 |      same as add_core, also:
 |      - output 2nd level residuals if residuals_2 != NULL
 |      - accepts precomputed_idx = nullptr
 |
 |  decode_multiple(self, n, keys, xcodes, x)
 |      inverse of encode_multiple
 |
 |  decode_vectors(self, n, codes, listnos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode(self, key, x, code)
 |
 |  encode_multiple(self, n, keys, x, codes, compute_keys=False)
 |       Encode multiple vectors
 |
 |      :type n: int
 |      :param n:       nb vectors to encode
 |      :type keys: int
 |      :param keys:    posting list ids for those vectors (size n)
 |      :type x: float
 |      :param x:       vectors (size n * d)
 |      :type codes: uint8_t
 |      :param codes:   output codes (size n * code_size)
 |      :type compute_keys: boolean, optional
 |      :param compute_keys:  if false, assume keys are precomputed,
 |                               otherwise compute them
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  find_duplicates(self, ids, lims)
 |       Find exact duplicates in the dataset.
 |
 |      the duplicates are returned in pre-allocated arrays (see the
 |      max sizes).
 |
 |      :type lims: int
 |      :param lims:   limits between groups of duplicates
 |                         (max size ntotal / 2 + 1)
 |      :type ids: int
 |      :param ids:    ids[lims[i]] : ids[lims[i+1]-1] is a group of
 |                         duplicates (max size ntotal)
 |      :rtype: int
 |      :return: n      number of groups found
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  precompute_table(self)
 |      build precomputed table
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  train_encoder(self, n, x, assign)
 |      trains the product quantizer
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFPQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  do_polysemous_training
 |      reorder PQ centroids after training?
 |
 |  polysemous_ht
 |      Hamming thresh for polysemous filtering
 |
 |  polysemous_training
 |      if NULL, use default
 |
 |  pq
 |      produces the codes
 |
 |  precomputed_table
 |      if use_precompute_table
 |      size nlist * pq.M * pq.ksub
 |
 |  scan_table_threshold
 |      use table computation or on-the-fly?
 |
 |  thisown
 |      The membership flag
 |
 |  use_precomputed_table
 |       Precompute table that speed up query preprocessing at some
 |      memory cost (used only for by_residual with L2 metric)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFPQFastScan in module faiss.swigfaiss

class IndexIVFPQFastScan(IndexIVFFastScan)
 |  IndexIVFPQFastScan(*args)
 |
 |   Fast scan version of IVFPQ. Works for 4-bit PQ for now.
 |
 |  The codes in the inverted lists are not stored sequentially but
 |  grouped in blocks of size bbs. This makes it possible to very quickly
 |  compute distances with SIMD instructions.
 |
 |  Implementations (implem):
 |  0: auto-select implementation (default)
 |  1: orig's search, re-implemented
 |  2: orig's search, re-ordered by invlist
 |  10: optimizer int16 search, collect results in heap, no qbs
 |  11: idem, collect results in reservoir
 |  12: optimizer int16 search, collect results in heap, uses qbs
 |  13: idem, collect results in reservoir
 |
 |  Method resolution order:
 |      IndexIVFPQFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |      same as the regular IVFPQ encoder. The codes are not reorganized by
 |      blocks a that point
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit PQ sub-quantizer nibbles)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, arg4)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  lookup_table_is_3d(self)
 |
 |  precompute_table(self)
 |      build precomputed table, possibly updating use_precomputed_table
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFPQFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  pq
 |      produces the codes
 |
 |  precomputed_table
 |      if use_precompute_table size (nlist, pq.M, pq.ksub)
 |
 |  thisown
 |      The membership flag
 |
 |  use_precomputed_table
 |      precomputed tables management
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search for k nearest neighbors
 |
 |      :type n: int
 |      :param n:          number of query vectors
 |      :type x: float
 |      :param x:          query vectors (n * d)
 |      :type k: int
 |      :param k:          number of nearest neighbors to find
 |      :type distances: float
 |      :param distances:  output distances (n * k)
 |      :type labels: int
 |      :param labels:     output labels/indices (n * k)
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:     optional search parameters
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFPQR in module faiss.swigfaiss

class IndexIVFPQR(IndexIVFPQ)
 |  IndexIVFPQR(*args)
 |
 |  Index with an additional level of PQ refinement
 |
 |  Method resolution order:
 |      IndexIVFPQR
 |      IndexIVFPQ
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |      same as add_with_ids, but optionally use the precomputed list ids
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  train_encoder(self, n, x, assign)
 |      trains the two product quantizers
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFPQR(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  k_factor
 |      factor between k requested in search and the k requested from the IVFPQ
 |
 |  refine_codes
 |      corresponding codes
 |
 |  refine_pq
 |      3rd level quantizer
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFPQ:
 |
 |  add_core_o(self, n, x, xids, residuals_2, precomputed_idx=None, inverted_list_context=None)
 |      same as add_core, also:
 |      - output 2nd level residuals if residuals_2 != NULL
 |      - accepts precomputed_idx = nullptr
 |
 |  decode_multiple(self, n, keys, xcodes, x)
 |      inverse of encode_multiple
 |
 |  decode_vectors(self, n, codes, listnos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode(self, key, x, code)
 |
 |  encode_multiple(self, n, keys, x, codes, compute_keys=False)
 |       Encode multiple vectors
 |
 |      :type n: int
 |      :param n:       nb vectors to encode
 |      :type keys: int
 |      :param keys:    posting list ids for those vectors (size n)
 |      :type x: float
 |      :param x:       vectors (size n * d)
 |      :type codes: uint8_t
 |      :param codes:   output codes (size n * code_size)
 |      :type compute_keys: boolean, optional
 |      :param compute_keys:  if false, assume keys are precomputed,
 |                               otherwise compute them
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  find_duplicates(self, ids, lims)
 |       Find exact duplicates in the dataset.
 |
 |      the duplicates are returned in pre-allocated arrays (see the
 |      max sizes).
 |
 |      :type lims: int
 |      :param lims:   limits between groups of duplicates
 |                         (max size ntotal / 2 + 1)
 |      :type ids: int
 |      :param ids:    ids[lims[i]] : ids[lims[i+1]-1] is a group of
 |                         duplicates (max size ntotal)
 |      :rtype: int
 |      :return: n      number of groups found
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  precompute_table(self)
 |      build precomputed table
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFPQ:
 |
 |  do_polysemous_training
 |      reorder PQ centroids after training?
 |
 |  polysemous_ht
 |      Hamming thresh for polysemous filtering
 |
 |  polysemous_training
 |      if NULL, use default
 |
 |  pq
 |      produces the codes
 |
 |  precomputed_table
 |      if use_precompute_table
 |      size nlist * pq.M * pq.ksub
 |
 |  scan_table_threshold
 |      use table computation or on-the-fly?
 |
 |  use_precomputed_table
 |       Precompute table that speed up query preprocessing at some
 |      memory cost (used only for by_residual with L2 metric)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFPQStats in module faiss.swigfaiss

class IndexIVFPQStats(builtins.object)
 |  statistics are robust to internal threading, but not if
 |  IndexIVFPQ::search_preassigned is called by multiple threads
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFPQStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n_hamming_pass
 |      nb of passed Hamming distance tests (for polysemous)
 |
 |  nrefine
 |      nb of refines (IVFPQR)
 |
 |  refine_cycles
 |      only for IVFPQR
 |
 |  search_cycles
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IndexIVFProductLocalSearchQuantizer in module faiss.swigfaiss

class IndexIVFProductLocalSearchQuantizer(IndexIVFAdditiveQuantizer)
 |  IndexIVFProductLocalSearchQuantizer(*args)
 |
 |   IndexIVF based on a product local search quantizer. Stored vectors are
 |  approximated by product local search quantization codes.
 |
 |  Method resolution order:
 |      IndexIVFProductLocalSearchQuantizer
 |      IndexIVFAdditiveQuantizer
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of local search quantizers
 |      :type Msub: int
 |      :param Msub:   number of subquantizers per LSQ
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFProductLocalSearchQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  plsq
 |      The product local search quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizer:
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
 |
 |  aq
 |
 |  use_precomputed_table
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFProductLocalSearchQuantizerFastScan in module faiss.swigfaiss

class IndexIVFProductLocalSearchQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
 |  IndexIVFProductLocalSearchQuantizerFastScan(*args)
 |
 |  Method resolution order:
 |      IndexIVFProductLocalSearchQuantizerFastScan
 |      IndexIVFAdditiveQuantizerFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFProductLocalSearchQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  plsq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.IndexIVFFastScan
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |      same as the regular IVFAQ encoder. The codes are not reorganized by
 |      blocks a that point
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, aq, nlist, metric, bbs, own_invlists)
 |
 |  lookup_table_is_3d(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.IndexIVFFastScan
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFProductResidualQuantizer in module faiss.swigfaiss

class IndexIVFProductResidualQuantizer(IndexIVFAdditiveQuantizer)
 |  IndexIVFProductResidualQuantizer(*args)
 |
 |   IndexIVF based on a product residual quantizer. Stored vectors are
 |  approximated by product residual quantization codes.
 |
 |  Method resolution order:
 |      IndexIVFProductResidualQuantizer
 |      IndexIVFAdditiveQuantizer
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of residual quantizers
 |      :type Msub: int
 |      :param Msub:   number of subquantizers per RQ
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFProductResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  prq
 |      The product residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizer:
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
 |
 |  aq
 |
 |  use_precomputed_table
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFProductResidualQuantizerFastScan in module faiss.swigfaiss

class IndexIVFProductResidualQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
 |  IndexIVFProductResidualQuantizerFastScan(*args)
 |
 |  Method resolution order:
 |      IndexIVFProductResidualQuantizerFastScan
 |      IndexIVFAdditiveQuantizerFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFProductResidualQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  prq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.IndexIVFFastScan
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |      same as the regular IVFAQ encoder. The codes are not reorganized by
 |      blocks a that point
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, aq, nlist, metric, bbs, own_invlists)
 |
 |  lookup_table_is_3d(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.IndexIVFFastScan
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFRaBitQ in module faiss.swigfaiss

class IndexIVFRaBitQ(IndexIVF)
 |  IndexIVFRaBitQ(*args)
 |
 |  Method resolution order:
 |      IndexIVFRaBitQ
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFRaBitQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  qb
 |
 |  rabitq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFRaBitQFastScan in module faiss.swigfaiss

class IndexIVFRaBitQFastScan(IndexIVFFastScan)
 |  IndexIVFRaBitQFastScan(*args)
 |
 |   Fast-scan version of IndexIVFRaBitQ that processes vectors in batches
 |  using SIMD operations. Combines the inverted file structure of IVF
 |  with RaBitQ's bit-level quantization and FastScan's batch processing.
 |
 |  Key features:
 |  - Inherits from IndexIVFFastScan for IVF structure and search algorithms
 |  - Processes 32 database vectors at a time using SIMD
 |  - Separates factors from quantized bits for efficient processing
 |  - Supports both L2 and inner product metrics
 |  - Maintains compatibility with existing IVF search parameters
 |
 |  Implementation details:
 |  - Batch size (bbs) is typically 32 for optimal SIMD performance
 |  - Factors are stored separately from packed codes for cache efficiency
 |  - Query factors are computed once per search and reused across lists
 |  - Uses specialized result handlers for RaBitQ distance corrections
 |
 |  Method resolution order:
 |      IndexIVFRaBitQFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |      Override: compute and quantize LUT per-query to avoid O(n*nprobe*M*16)
 |      float table allocation.
 |
 |  compute_per_vector_storage_size(self)
 |      Compute per-vector auxiliary storage size based on nb_bits
 |
 |  compute_residual_LUT(self, query, centroid_id, query_factors, lut_out, qb_param, centered_param, rotated_q, centroid_buf)
 |      Compute residual, query factors, and float LUT in two passes over d.
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: (d + 7) / 8 bytes (1-bit-per-dimension sign bits,
 |      excluding factors)
 |
 |  get_CodePacker(self)
 |      Return CodePackerRaBitQ with enlarged block size
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |      Get an InvertedListScanner for single-query scanning.
 |      This provides compatibility with the standard IVF search interface
 |
 |  lookup_table_is_3d(self)
 |      Implementation methods for IVFRaBitQFastScan specialization
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |      Write per-vector auxiliary data into block auxiliary region
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |      Reconstruct a single vector from an inverted list
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |      Override sa_decode to handle RaBitQ reconstruction
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFRaBitQFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centered
 |      Use zero-centered scalar quantizer for queries
 |
 |  qb
 |      Default number of bits to quantize a query with
 |
 |  rabitq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_orig_invlists(self)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search for k nearest neighbors
 |
 |      :type n: int
 |      :param n:          number of query vectors
 |      :type x: float
 |      :param x:          query vectors (n * d)
 |      :type k: int
 |      :param k:          number of nearest neighbors to find
 |      :type distances: float
 |      :param distances:  output distances (n * k)
 |      :type labels: int
 |      :param labels:     output labels/indices (n * k)
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:     optional search parameters
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFResidualQuantizer in module faiss.swigfaiss

class IndexIVFResidualQuantizer(IndexIVFAdditiveQuantizer)
 |  IndexIVFResidualQuantizer(*args)
 |
 |   IndexIVF based on a residual quantizer. Stored vectors are
 |  approximated by residual quantization codes.
 |
 |  Method resolution order:
 |      IndexIVFResidualQuantizer
 |      IndexIVFAdditiveQuantizer
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rq
 |      The residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizer:
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
 |
 |  aq
 |
 |  use_precomputed_table
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFResidualQuantizerFastScan in module faiss.swigfaiss

class IndexIVFResidualQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
 |  IndexIVFResidualQuantizerFastScan(*args)
 |
 |  Method resolution order:
 |      IndexIVFResidualQuantizerFastScan
 |      IndexIVFAdditiveQuantizerFastScan
 |      IndexIVFFastScan
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFResidualQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.IndexIVFFastScan
 |       Add vectors with specific IDs to the index
 |
 |      :type n: int
 |      :param n:     number of vectors to add
 |      :type x: float
 |      :param x:     vectors to add (n * d)
 |      :type xids: int
 |      :param xids:  IDs for the vectors (n)
 |
 |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
 |      same as the regular IVFAQ encoder. The codes are not reorganized by
 |      blocks a that point
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, aq, nlist, metric, bbs, own_invlists)
 |
 |  lookup_table_is_3d(self)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Range search for all neighbors within radius
 |
 |      :type n: int
 |      :param n:       number of query vectors
 |      :type x: float
 |      :param x:       query vectors (n * d)
 |      :type radius: float
 |      :param radius:  search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:  output range search results
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:  optional search parameters
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.IndexIVFFastScan
 |       Decode a set of vectors
 |
 |      NOTE: The codes in the IndexFastScan object are non-contiguous.
 |            But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from faiss.swigfaiss.IndexIVFFastScan
 |       Search with pre-assigned coarse quantization
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type k: int
 |      :param k:             number of nearest neighbors to find
 |      :type assign: int
 |      :param assign:        coarse cluster assignments (n * nprobe)
 |      :type centroid_dis: float
 |      :param centroid_dis:  distances to centroids (n * nprobe)
 |      :type distances: float
 |      :param distances:     output distances (n * k)
 |      :type labels: int
 |      :param labels:        output labels/indices (n * k)
 |      :type store_pairs: boolean
 |      :param store_pairs:   whether to store cluster-relative pairs
 |      :type params: :py:class:`IVFSearchParameters`, optional
 |      :param params:        optional IVF search parameters
 |      :type stats: :py:class:`IndexIVFStats`, optional
 |      :param stats:         optional search statistics
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVFFastScan:
 |
 |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
 |       Compute quantized lookup tables for distance computation
 |
 |      :type n: int
 |      :param n:             number of query vectors
 |      :type x: float
 |      :param x:             query vectors (n * d)
 |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
 |      :param cq:            coarse quantization results
 |      :type dis_tables: faiss::AlignedTable< uint8_t >
 |      :param dis_tables:    output quantized distance tables
 |      :type biases: faiss::AlignedTable< uint16_t >
 |      :param biases:        output quantized bias values
 |      :type normalizers: float
 |      :param normalizers:   output normalization factors
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:       processing context containing query factors
 |          processor
 |
 |  get_CodePacker(self)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_code_packer(self)
 |
 |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
 |       Initialize the fast scan functionality (called by implementations)
 |
 |      :type fine_quantizer: :py:class:`Quantizer`
 |      :param fine_quantizer:  fine quantizer for encoding
 |      :type M: int
 |      :param M:               number of subquantizers
 |      :type nbits: int
 |      :param nbits:           number of bits per subquantizer
 |      :type nlist: int
 |      :param nlist:           number of inverted lists
 |      :type metric: int
 |      :param metric:          distance metric to use
 |      :type bbs: int
 |      :param bbs:             block size for SIMD processing
 |      :type own_invlists: boolean
 |      :param own_invlists:    whether to own the inverted lists
 |
 |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
 |       Post-process packed codes after pq4_pack_codes_range.
 |
 |      Called during add_with_ids after codes have been packed into
 |      SIMD-friendly blocks.
 |
 |      :type list_no: int
 |      :param list_no:       inverted list number
 |      :type list_offset: int
 |      :param list_offset:   starting offset within the list (pre-existing size)
 |      :type n_added: int
 |      :param n_added:       number of vectors added in this batch
 |      :type flat_codes: uint8_t
 |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
 |
 |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_orig_invlists(self)
 |
 |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
 |
 |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  fine_quantizer
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  orig_invlists
 |      orig's inverted lists (for debugging)
 |
 |  qbs
 |
 |  qbs2
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFScalarQuantizer in module faiss.swigfaiss

class IndexIVFScalarQuantizer(IndexIVF)
 |  IndexIVFScalarQuantizer(*args)
 |
 |  Method resolution order:
 |      IndexIVFScalarQuantizer
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFScalarQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  sq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFSpectralHash in module faiss.swigfaiss

class IndexIVFSpectralHash(IndexIVF)
 |  IndexIVFSpectralHash(*args)
 |
 |   Inverted list that stores binary codes of size nbit. Before the
 |  binary conversion, the dimension of the vectors is transformed from
 |  dim d into dim nbit by vt (a random rotation by default).
 |
 |  Each coordinate is subtracted from a value determined by
 |  threshold_type, and split into intervals of size period. Half of
 |  the interval is a 0 bit, the other half a 1.
 |
 |  Method resolution order:
 |      IndexIVFSpectralHash
 |      IndexIVF
 |      Index
 |      IndexIVFInterface
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
 |       Encodes a set of vectors as they would appear in the inverted lists
 |
 |      :type list_nos: int
 |      :param list_nos:   inverted list ids as returned by the
 |                            quantizer (size n). -1s are ignored.
 |      :type codes: uint8_t
 |      :param codes:      output codes, size n * code_size
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  get_InvertedListScanner(self, store_pairs, sel, params)
 |       Get a scanner for this index (store_pairs means ignore labels)
 |
 |      The default search implementation uses this to compute the distances.
 |      Use sel instead of params->sel, because sel is initialized with
 |      params->sel, but may get overridden by IndexIVF's internal logic.
 |
 |  replace_vt = replacement_method(self, ref, own=False) from faiss.add_ref_in_method_explicit_own.<locals>
 |
 |  train_encoder(self, n, x, assign)
 |       Train the encoder for the vectors.
 |
 |      If by_residual then it is called with residuals and corresponding assign
 |      array, otherwise x is the raw training vectors and assign=nullptr
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFSpectralHash(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  nbit
 |      nb of bits of the binary signature
 |
 |  own_fields
 |      own the vt
 |
 |  period
 |      interval size for 0s and 1s
 |
 |  thisown
 |      The membership flag
 |
 |  threshold_type
 |
 |  trained
 |      Trained threshold.
 |      size nlist * nbit or 0 if Thresh_global
 |
 |  vt
 |      transformation from d to nbit dim
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  Thresh_centroid = 1
 |
 |  Thresh_centroid_half = 2
 |
 |  Thresh_global = 0
 |
 |  Thresh_median = 3
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexIVF:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      Calls add_with_ids with NULL ids
 |
 |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
 |       Implementation of vector addition where the vector assignments are
 |      predefined. The default implementation hands over the code extraction to
 |      encode_vectors.
 |
 |      :type precomputed_idx: int
 |      :param precomputed_idx:    quantization indices for the input vectors
 |          (size n)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      default implementation that calls encode_vectors
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  check_ids_sorted(self)
 |      are the ids sorted?
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      see Invlists::copy_subset_to for the meaning of subset_type
 |
 |  decode_vectors(self, n, codes, list_nos, x)
 |       Decodes a set of vectors as they would appear in a given set of inverted
 |      lists (inverse of encode_vectors)
 |
 |      :type codes: uint8_t
 |      :param codes:      input codes, size n * code_size
 |      :type x: float
 |      :param x:          output decoded vectors
 |      :type list_nos: int
 |      :param list_nos:   input listnos, size n
 |
 |  get_CodePacker(self)
 |
 |  get_list_size(self, list_no)
 |
 |  make_direct_map(self, new_maintain_direct_map=True)
 |       initialize a direct map
 |
 |      :type new_maintain_direct_map: boolean, optional
 |      :param new_maintain_direct_map:    if true, create a direct map,
 |                                            else clear it
 |
 |  merge_from(self, otherIndex, add_id)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
 |
 |  reconstruct_from_offset(self, list_no, offset, recons)
 |       Reconstruct a vector given the location in terms of (inv list index +
 |      inv list offset) instead of the id.
 |
 |      Useful for reconstructing when the direct_map is not maintained and
 |      the inv list offset is computed by search_preassigned() with
 |      `store_pairs` set.
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct a subset of the indexed vectors.
 |
 |      Overrides default implementation to bypass reconstruct() which requires
 |      direct_map to be maintained.
 |
 |      :type i0: int
 |      :param i0:     first vector to reconstruct
 |      :type ni: int
 |      :param ni:     nb of vectors to reconstruct
 |      :type recons: float
 |      :param recons: output array of reconstructed vectors, size ni * d
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Dataset manipulation functions
 |
 |  replace_invlists(self, il, own=False)
 |      replace the inverted lists, old one is deallocated if own_invlists
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |      sa_encode will call encode_vectors with include_listno=true
 |      :type n: int
 |      :param n:      nb of vectors to encode
 |      :type x: float
 |      :param x:      the vectors to encode
 |      :type bytes: uint8_t
 |      :param bytes:  output array for the codes
 |      :rtype: void
 |      :return: nb of bytes written to codes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      Overrides default implementation to avoid having to maintain direct_map
 |      and instead fetch the code offsets through the `store_pairs` flag in
 |      search_preassigned().
 |
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return the codes stored for these vectors
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      include_listnos : bool, optional
 |          whether to include the list ids in the first bytes of each code
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      codes : array_like, optional
 |          codes array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
 |       Similar to search, but also returns the codes corresponding to the
 |      stored vectors for the search results.
 |
 |      :param codes:      codes (n, k, code_size)
 |      :type include_listno: boolean, optional
 |      :param include_listno:
 |                            include the list ids in the code (in this case add
 |                            ceil(log8(nlist)) to the code size)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      assign the vectors, then call search_preassign
 |
 |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in an IVF index,
 |      with precalculated coarse quantization assignment.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      Dq : array_like, optional
 |          Distance array to the centroids, size (n, nprobe)
 |      Iq : array_like, optional
 |          Nearest centroids, size (n, nprobe)
 |
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
 |
 |  set_direct_map_type(self, type)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the quantizer and calls train_encoder to train sub-quantizers
 |
 |  train_encoder_num_vectors(self)
 |      can be redefined by subclasses to indicate how many training vectors
 |      they need
 |
 |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  update_vectors_c = update_vectors(self, nv, idx, v)
 |       Update a subset of vectors.
 |
 |      The index must have a direct_map
 |
 |      :type nv: int
 |      :param nv:     nb of vectors to update
 |      :type idx: int
 |      :param idx:    vector indices to update, size nv
 |      :type v: float
 |      :param v:      vectors of new values, size nv*d
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from IndexIVF:
 |
 |  PARALLEL_MODE_NO_HEAP_INIT
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVF:
 |
 |  by_residual
 |      do the codes in the invlists encode the vectors relative to the
 |      centroids?
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  direct_map
 |      optional map that maps back ids to invlist entries. This
 |      enables reconstruct()
 |
 |  invlists
 |      Access to the actual data
 |
 |  own_invlists
 |
 |  parallel_mode
 |       Parallel mode determines how queries are parallelized with OpenMP
 |
 |      0 (default): split over queries
 |      1: parallelize over inverted lists
 |      2: parallelize over both
 |      3: split over queries with a finer granularity
 |
 |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
 |      prevent the heap to be initialized and finalized
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexIVFInterface:
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  nprobe
 |      number of probes at query time
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexIVFStats in module faiss.swigfaiss

class IndexIVFStats(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, other)
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexIVFStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ndis
 |
 |  nheap_updates
 |
 |  nlist
 |
 |  nq
 |
 |  quantization_time
 |
 |  search_time
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IndexLSH in module faiss.swigfaiss

class IndexLSH(IndexFlatCodes)
 |  IndexLSH(*args)
 |
 |  The sign of each vector component is put in a binary signature
 |
 |  Method resolution order:
 |      IndexLSH
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  apply_preprocess(self, n, x)
 |       Preprocesses and resizes the input to the size required to
 |      binarize the data
 |
 |      :type x: float
 |      :param x: input vectors, size n * d
 |      :rtype: float
 |      :return: output vectors, size n * bits. May be the same pointer
 |                  as x, otherwise it should be deleted by the caller
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  transfer_thresholds(self, vt)
 |      transfer the thresholds to a pre-processing stage (and unset
 |      train_thresholds)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexLSH(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  nbits
 |      nb of bits per vector
 |
 |  rotate_data
 |      whether to apply a random rotation to input
 |
 |  rrot
 |      optional random rotation
 |
 |  thisown
 |      The membership flag
 |
 |  thresholds
 |      thresholds to compare with
 |
 |  train_thresholds
 |      whether we train thresholds or use 0
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexLattice in module faiss.swigfaiss

class IndexLattice(IndexFlatCodes)
 |  IndexLattice(d, nsq, scale_nbit, r2)
 |
 |  Index that encodes a vector with a series of Zn lattice quantizers
 |
 |  Method resolution order:
 |      IndexLattice
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, d, nsq, scale_nbit, r2)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexLattice(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  dsq
 |      dimension of sub-vectors
 |
 |  lattice_nbit
 |
 |  nsq
 |      number of sub-vectors
 |
 |  scale_nbit
 |      nb bits used to encode the scale, per subvector
 |
 |  thisown
 |      The membership flag
 |
 |  trained
 |      mins and maxes of the vector norms, per subquantizer
 |
 |  zn_sphere_codec
 |      the lattice quantizer
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search implemented by decoding (most index types will have a faster
 |      implementation)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexLocalSearchQuantizer in module faiss.swigfaiss

class IndexLocalSearchQuantizer(IndexAdditiveQuantizer)
 |  IndexLocalSearchQuantizer(*args)
 |
 |  Method resolution order:
 |      IndexLocalSearchQuantizer
 |      IndexAdditiveQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexLocalSearchQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lsq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizer:
 |
 |  aq
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexLocalSearchQuantizerFastScan in module faiss.swigfaiss

class IndexLocalSearchQuantizerFastScan(IndexAdditiveQuantizerFastScan)
 |  IndexLocalSearchQuantizerFastScan(*args)
 |
 |   Index based on a local search quantizer. Stored vectors are
 |  approximated by local search quantization codes.
 |  Can also be used as a codec
 |
 |  Method resolution order:
 |      IndexLocalSearchQuantizerFastScan
 |      IndexAdditiveQuantizerFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |      :type metric: int, optional
 |      :param metric:  metric type
 |      :type search_type: int, optional
 |      :param search_type: AQ search type
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexLocalSearchQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lsq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizerFastScan:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFastScan
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, *args)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFastScan
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFastScan
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors.
 |
 |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
 |             contiguous. But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.IndexFastScan
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNNDescent in module faiss.swigfaiss

class IndexNNDescent(Index)
 |  IndexNNDescent(*args)
 |
 |   The NNDescent index is a normal random-access index with an NNDescent
 |  link structure built on top
 |
 |  Method resolution order:
 |      IndexNNDescent
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNNDescent(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  nndescent
 |      Faiss results are 64-bit
 |
 |  own_fields
 |
 |  storage
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNNDescentFlat in module faiss.swigfaiss

class IndexNNDescentFlat(IndexNNDescent)
 |  IndexNNDescentFlat(*args)
 |
 |  Flat index topped with with a NNDescent structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexNNDescentFlat
 |      IndexNNDescent
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNNDescentFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexNNDescent:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexNNDescent:
 |
 |  nndescent
 |      Faiss results are 64-bit
 |
 |  own_fields
 |
 |  storage
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNSG in module faiss.swigfaiss

class IndexNSG(Index)
 |  IndexNSG(*args)
 |
 |   The NSG index is a normal random-access index with a NSG
 |  link structure built on top
 |
 |  Method resolution order:
 |      IndexNSG
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
 |
 |  build_c = build(self, n, x, knn_graph, GK)
 |
 |  check_knn_graph(self, knn_graph, n, K)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNSG(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  GK
 |      K of KNN graph for building
 |
 |  build_type
 |      indicate how to build a knn graph
 |      - 0: build NSG with brute force search
 |      - 1: build NSG with NNDescent
 |
 |  is_built
 |      the index is built or not
 |
 |  nndescent_L
 |
 |  nndescent_R
 |
 |  nndescent_S
 |      parameters for nndescent
 |
 |  nndescent_iter
 |
 |  nsg
 |      the link structure
 |
 |  own_fields
 |      the sequential storage
 |
 |  storage
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNSGFlat in module faiss.swigfaiss

class IndexNSGFlat(IndexNSG)
 |  IndexNSGFlat(*args)
 |
 |  Flat index topped with with a NSG structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexNSGFlat
 |      IndexNSG
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNSGFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexNSG:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
 |
 |  build_c = build(self, n, x, knn_graph, GK)
 |
 |  check_knn_graph(self, knn_graph, n, K)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexNSG:
 |
 |  GK
 |      K of KNN graph for building
 |
 |  build_type
 |      indicate how to build a knn graph
 |      - 0: build NSG with brute force search
 |      - 1: build NSG with NNDescent
 |
 |  is_built
 |      the index is built or not
 |
 |  nndescent_L
 |
 |  nndescent_R
 |
 |  nndescent_S
 |      parameters for nndescent
 |
 |  nndescent_iter
 |
 |  nsg
 |      the link structure
 |
 |  own_fields
 |      the sequential storage
 |
 |  storage
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNSGPQ in module faiss.swigfaiss

class IndexNSGPQ(IndexNSG)
 |  IndexNSGPQ(*args)
 |
 |  PQ index topped with with a NSG structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexNSGPQ
 |      IndexNSG
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNSGPQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexNSG:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
 |
 |  build_c = build(self, n, x, knn_graph, GK)
 |
 |  check_knn_graph(self, knn_graph, n, K)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexNSG:
 |
 |  GK
 |      K of KNN graph for building
 |
 |  build_type
 |      indicate how to build a knn graph
 |      - 0: build NSG with brute force search
 |      - 1: build NSG with NNDescent
 |
 |  is_built
 |      the index is built or not
 |
 |  nndescent_L
 |
 |  nndescent_R
 |
 |  nndescent_S
 |      parameters for nndescent
 |
 |  nndescent_iter
 |
 |  nsg
 |      the link structure
 |
 |  own_fields
 |      the sequential storage
 |
 |  storage
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNSGSQ in module faiss.swigfaiss

class IndexNSGSQ(IndexNSG)
 |  IndexNSGSQ(*args)
 |
 |  SQ index topped with with a NSG structure to access elements
 |  more efficiently.
 |
 |  Method resolution order:
 |      IndexNSGSQ
 |      IndexNSG
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNSGSQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexNSG:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
 |
 |  build_c = build(self, n, x, knn_graph, GK)
 |
 |  check_knn_graph(self, knn_graph, n, K)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      entry point for search
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Trains the storage if needed
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexNSG:
 |
 |  GK
 |      K of KNN graph for building
 |
 |  build_type
 |      indicate how to build a knn graph
 |      - 0: build NSG with brute force search
 |      - 1: build NSG with NNDescent
 |
 |  is_built
 |      the index is built or not
 |
 |  nndescent_L
 |
 |  nndescent_R
 |
 |  nndescent_S
 |      parameters for nndescent
 |
 |  nndescent_iter
 |
 |  nsg
 |      the link structure
 |
 |  own_fields
 |      the sequential storage
 |
 |  storage
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexNeuralNetCodec in module faiss.swigfaiss

class IndexNeuralNetCodec(IndexFlatCodes)
 |  IndexNeuralNetCodec(*args)
 |
 |  Method resolution order:
 |      IndexNeuralNetCodec
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, codes)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexNeuralNetCodec(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |
 |  nbits
 |
 |  net
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search implemented by decoding (most index types will have a faster
 |      implementation)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexPQ in module faiss.swigfaiss

class IndexPQ(IndexFlatCodes)
 |  IndexPQ(*args)
 |
 |   Index based on a product quantizer. Stored vectors are
 |  approximated by PQ codes.
 |
 |  Method resolution order:
 |      IndexPQ
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  hamming_distance_histogram(self, n, x, nb, xb, dist_histogram)
 |      prepare query for a polysemous search, but instead of
 |      computing the result, just get the histogram of Hamming
 |      distances. May be computed on a provided dataset if xb != NULL
 |      :type dist_histogram: int
 |      :param dist_histogram: (M * nbits + 1)
 |
 |  hamming_distance_table(self, n, x, dis)
 |       compute pairwise distances between queries and database
 |
 |      :type n: int
 |      :param n:    nb of query vectors
 |      :type x: float
 |      :param x:    query vector, size n * d
 |      :type dis: int
 |      :param dis:  output distances, size n * ntotal
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_core_polysemous(self, n, x, k, distances, labels, polysemous_ht, generalized_hamming)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexPQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  do_polysemous_training
 |      false = standard PQ
 |
 |  encode_signs
 |
 |  polysemous_ht
 |      Hamming threshold used for polysemy
 |
 |  polysemous_training
 |      parameters used for the polysemous training
 |
 |  pq
 |      The product quantizer used to encode the vectors
 |
 |  search_type
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  ST_HE = 1
 |
 |  ST_PQ = 0
 |
 |  ST_SDC = 3
 |
 |  ST_generalized_HE = 2
 |
 |  ST_polysemous = 4
 |
 |  ST_polysemous_generalize = 5
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexPQFastScan in module faiss.swigfaiss

class IndexPQFastScan(IndexFastScan)
 |  IndexPQFastScan(*args)
 |
 |   Fast scan version of IndexPQ. Works for 4-bit PQ for now.
 |
 |  The codes are not stored sequentially but grouped in blocks of size bbs.
 |  This makes it possible to compute distances quickly with SIMD instructions.
 |
 |  Implementations:
 |  12: blocked loop with internal loop on Q with qbs
 |  13: same with reservoir accumulator to store results
 |  14: no qbs with heap accumulator
 |  15: no qbs with reservoir accumulator
 |
 |  Method resolution order:
 |      IndexPQFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      build from an existing IndexPQ
 |
 |      |
 |
 |      *Overload 2:*
 |      build from an existing IndexPQ
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit PQ sub-quantizer nibbles)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexPQFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  pq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search for k nearest neighbors
 |
 |      :type n: int
 |      :param n:          number of query vectors
 |      :type x: float
 |      :param x:          query vectors (n * d)
 |      :type k: int
 |      :param k:          number of nearest neighbors to find
 |      :type distances: float
 |      :param distances:  output distances (n * k)
 |      :type labels: int
 |      :param labels:     output labels/indices (n * k)
 |      :type params: :py:class:`SearchParameters`, optional
 |      :param params:     optional search parameters
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexPQStats in module faiss.swigfaiss

class IndexPQStats(builtins.object)
 |  statistics are robust to internal threading, but not if
 |  IndexPQ::search is called by multiple threads
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexPQStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n_hamming_pass
 |
 |  ncode
 |
 |  nq
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IndexPreTransform in module faiss.swigfaiss

class IndexPreTransform(Index)
 |  IndexPreTransform(*args)
 |
 |  Index that applies a LinearTransform transform on vectors before
 |  handing them over to a sub-index
 |
 |  Method resolution order:
 |      IndexPreTransform
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  apply_chain(self, n, x)
 |      apply the transforms in the chain. The returned float * may be
 |      equal to x, otherwise it should be deallocated.
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  prepend_transform = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      removes IDs from the index. Not supported by all indexes.
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  reverse_chain(self, n, xt, x)
 |      Reverse the transforms in the chain. May not be implemented for
 |      all transforms in the chain or may return approximate results.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexPreTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  chain
 |
 |  index
 |      chain of transforms
 |
 |  own_fields
 |      the sub-index
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexProductLocalSearchQuantizer in module faiss.swigfaiss

class IndexProductLocalSearchQuantizer(IndexAdditiveQuantizer)
 |  IndexProductLocalSearchQuantizer(*args)
 |
 |  Index based on a product local search quantizer.
 |
 |  Method resolution order:
 |      IndexProductLocalSearchQuantizer
 |      IndexAdditiveQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of local search quantizers
 |      :type Msub: int
 |      :param Msub:     number of subquantizers per LSQ
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits: number of local search quantizers
 |      :type Msub: int
 |      :param Msub: number of subquantizers per LSQ
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexProductLocalSearchQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  plsq
 |      The product local search quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizer:
 |
 |  aq
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexProductLocalSearchQuantizerFastScan in module faiss.swigfaiss

class IndexProductLocalSearchQuantizerFastScan(IndexAdditiveQuantizerFastScan)
 |  IndexProductLocalSearchQuantizerFastScan(*args)
 |
 |   Index based on a product local search quantizer. Stored vectors are
 |  approximated by product local search quantization codes.
 |  Can also be used as a codec
 |
 |  Method resolution order:
 |      IndexProductLocalSearchQuantizerFastScan
 |      IndexAdditiveQuantizerFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of local search quantizers
 |      :type Msub: int
 |      :param Msub:     number of subquantizers per LSQ
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |      :type metric: int, optional
 |      :param metric:  metric type
 |      :type search_type: int, optional
 |      :param search_type: AQ search type
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits: number of local search quantizers
 |      :type Msub: int
 |      :param Msub: number of subquantizers per LSQ
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexProductLocalSearchQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  plsq
 |      The product local search quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizerFastScan:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFastScan
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, *args)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFastScan
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFastScan
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors.
 |
 |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
 |             contiguous. But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.IndexFastScan
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexProductResidualQuantizer in module faiss.swigfaiss

class IndexProductResidualQuantizer(IndexAdditiveQuantizer)
 |  IndexProductResidualQuantizer(*args)
 |
 |  Index based on a product residual quantizer.
 |
 |  Method resolution order:
 |      IndexProductResidualQuantizer
 |      IndexAdditiveQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of residual quantizers
 |      :type Msub: int
 |      :param Msub:      number of subquantizers per RQ
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits: number of residual quantizers
 |      :type Msub: int
 |      :param Msub: number of subquantizers per RQ
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexProductResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  prq
 |      The product residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizer:
 |
 |  aq
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexProductResidualQuantizerFastScan in module faiss.swigfaiss

class IndexProductResidualQuantizerFastScan(IndexAdditiveQuantizerFastScan)
 |  IndexProductResidualQuantizerFastScan(*args)
 |
 |   Index based on a product residual quantizer. Stored vectors are
 |  approximated by product residual quantization codes.
 |  Can also be used as a codec
 |
 |  Method resolution order:
 |      IndexProductResidualQuantizerFastScan
 |      IndexAdditiveQuantizerFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of residual quantizers
 |      :type Msub: int
 |      :param Msub:     number of subquantizers per RQ
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |      :type metric: int, optional
 |      :param metric:  metric type
 |      :type search_type: int, optional
 |      :param search_type: AQ search type
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits: number of residual quantizers
 |      :type Msub: int
 |      :param Msub: number of subquantizers per RQ
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexProductResidualQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  prq
 |      The product residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizerFastScan:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFastScan
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, *args)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFastScan
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFastScan
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors.
 |
 |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
 |             contiguous. But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.IndexFastScan
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexReplicas in module faiss.swigfaiss

class IndexReplicas(ThreadedIndexBase)
 |  IndexReplicas(*args)
 |
 |  Takes individual faiss::Index instances, and splits queries for
 |  sending to each Index instance, and joins the results together
 |  when done.
 |  Each index is managed by a separate CPU thread.
 |
 |  Method resolution order:
 |      IndexReplicas
 |      ThreadedIndexBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      The dimension that all sub-indices must share will be the dimension of
 |      the first sub-index added
 |      :type threaded: boolean, optional
 |      :param threaded: do we use one thread per sub-index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 2:*
 |      :type d: int
 |      :param d: the dimension that all sub-indices must share
 |      :type threaded: boolean, optional
 |      :param threaded: do we use one thread per sub index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 3:*
 |      :type d: int
 |      :param d: the dimension that all sub-indices must share
 |      :param threaded: do we use one thread per sub index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 4:*
 |      int version due to the implicit bool conversion ambiguity of int as
 |      dimension
 |
 |      |
 |
 |      *Overload 5:*
 |      int version due to the implicit bool conversion ambiguity of int as
 |      dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  addIndex = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  add_c = add(self, n, x)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  add_replica(self, index)
 |      Alias for addIndex()
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, arg2, v)
 |      reconstructs from the first index
 |
 |  remove_replica(self, index)
 |      Alias for removeIndex()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      faiss::Index API
 |      Query is partitioned into a slice for each sub-index
 |      split by ceil(n / #indices) for our sub-indices
 |
 |  syncWithSubIndexes(self)
 |      Synchronize the top-level index (IndexShards) with data in the
 |      sub-indices
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexReplicas(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ThreadedIndexBase:
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ThreadedIndexBase:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexQINCo in module faiss.swigfaiss

class IndexQINCo(IndexNeuralNetCodec)
 |  IndexQINCo(*args)
 |
 |  Method resolution order:
 |      IndexQINCo
 |      IndexNeuralNetCodec
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexQINCo(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  qinco
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexNeuralNetCodec:
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, codes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, codes)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexNeuralNetCodec:
 |
 |  M
 |
 |  nbits
 |
 |  net
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Search implemented by decoding (most index types will have a faster
 |      implementation)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRaBitQ in module faiss.swigfaiss

class IndexRaBitQ(IndexFlatCodes)
 |  IndexRaBitQ(*args)
 |
 |  Method resolution order:
 |      IndexRaBitQ
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  get_quantized_distance_computer(self, qb_in, centered)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRaBitQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  center
 |
 |  centered
 |
 |  qb
 |
 |  rabitq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRaBitQFastScan in module faiss.swigfaiss

class IndexRaBitQFastScan(IndexFastScan)
 |  IndexRaBitQFastScan(*args)
 |
 |   Fast-scan version of RaBitQ index that processes 32 database vectors at a
 |  time using SIMD operations. Similar to IndexPQFastScan but adapted for
 |  RaBitQ's bit-level quantization with factors.
 |
 |  The key differences from IndexRaBitQ:
 |  - Processes vectors in batches of 32
 |  - Uses 4-bit groupings for SIMD optimization (4 dimensions per 4-bit unit)
 |  - Separates factors from quantized bits for efficient processing
 |  - Leverages existing PQ4 FastScan infrastructure where possible
 |
 |  Method resolution order:
 |      IndexRaBitQFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      build from an existing IndexRaBitQ
 |
 |      |
 |
 |      *Overload 2:*
 |      build from an existing IndexRaBitQ
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  compute_per_vector_storage_size(self)
 |      Compute per-vector auxiliary data size in block aux region
 |
 |  fast_scan_code_size(self)
 |      Packed code size: (d + 7) / 8 bytes (1-bit-per-dimension sign bits,
 |      excluding factors)
 |
 |  get_CodePacker(self)
 |      Return CodePackerRaBitQ with enlarged block size
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Remove vectors and compact both PQ4 codes and auxiliary data
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRaBitQFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  center
 |      Center of all points (same as IndexRaBitQ)
 |
 |  centered
 |
 |  qb
 |      Default number of bits to quantize a query with
 |
 |  rabitq
 |      RaBitQ quantizer for encoding/decoding
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRandom in module faiss.swigfaiss

class IndexRandom(Index)
 |  IndexRandom(*args)
 |
 |   index that returns random results.
 |  used mainly for time benchmarks
 |
 |  Method resolution order:
 |      IndexRandom
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRandom(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  seed
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRefine in module faiss.swigfaiss

class IndexRefine(Index)
 |  IndexRefine(*args)
 |
 |  Index that queries in a base_index (a fast one) and refines the
 |  results with an exact search, hopefully improving the results.
 |
 |  Method resolution order:
 |      IndexRefine
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |      The sa_decode decodes from the index_refine, which is assumed to be more
 |      accurate
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRefine(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  base_index
 |      faster index to pre-select the vectors that should be filtered
 |
 |  k_factor
 |      factor between k requested in search and the k requested from
 |      the base_index (should be >= 1)
 |
 |  own_fields
 |      should the base index be deallocated?
 |
 |  own_refine_index
 |      same with the refinement index
 |
 |  refine_index
 |      refinement index
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRefineFlat in module faiss.swigfaiss

class IndexRefineFlat(IndexRefine)
 |  IndexRefineFlat(*args)
 |
 |   Version where the refinement index is an IndexFlat. It has one additional
 |  constructor that takes a table of elements to add to the flat refinement
 |  index
 |
 |  Method resolution order:
 |      IndexRefineFlat
 |      IndexRefine
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRefineFlat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexRefine:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |      The sa_decode decodes from the index_refine, which is assumed to be more
 |      accurate
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexRefine:
 |
 |  base_index
 |      faster index to pre-select the vectors that should be filtered
 |
 |  k_factor
 |      factor between k requested in search and the k requested from
 |      the base_index (should be >= 1)
 |
 |  own_fields
 |      should the base index be deallocated?
 |
 |  own_refine_index
 |      same with the refinement index
 |
 |  refine_index
 |      refinement index
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRefinePanorama in module faiss.swigfaiss

class IndexRefinePanorama(IndexRefine)
 |  IndexRefinePanorama(*args)
 |
 |   Version where the search calls search_subset, allowing for Panorama
 |  refinement.
 |
 |  Method resolution order:
 |      IndexRefinePanorama
 |      IndexRefine
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRefinePanorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexRefine:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |      The sa_decode decodes from the index_refine, which is assumed to be more
 |      accurate
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexRefine:
 |
 |  base_index
 |      faster index to pre-select the vectors that should be filtered
 |
 |  k_factor
 |      factor between k requested in search and the k requested from
 |      the base_index (should be >= 1)
 |
 |  own_fields
 |      should the base index be deallocated?
 |
 |  own_refine_index
 |      same with the refinement index
 |
 |  refine_index
 |      refinement index
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRefineSearchParameters in module faiss.swigfaiss

class IndexRefineSearchParameters(SearchParameters)
 |  IndexRefineSearchParameters(**args)
 |
 |  Method resolution order:
 |      IndexRefineSearchParameters
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRefineSearchParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  base_index_params
 |
 |  k_factor
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class IndexReplicas in module faiss.swigfaiss

class IndexReplicas(ThreadedIndexBase)
 |  IndexReplicas(*args)
 |
 |  Takes individual faiss::Index instances, and splits queries for
 |  sending to each Index instance, and joins the results together
 |  when done.
 |  Each index is managed by a separate CPU thread.
 |
 |  Method resolution order:
 |      IndexReplicas
 |      ThreadedIndexBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      The dimension that all sub-indices must share will be the dimension of
 |      the first sub-index added
 |      :type threaded: boolean, optional
 |      :param threaded: do we use one thread per sub-index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 2:*
 |      :type d: int
 |      :param d: the dimension that all sub-indices must share
 |      :type threaded: boolean, optional
 |      :param threaded: do we use one thread per sub index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 3:*
 |      :type d: int
 |      :param d: the dimension that all sub-indices must share
 |      :param threaded: do we use one thread per sub index or do queries
 |          sequentially?
 |
 |      |
 |
 |      *Overload 4:*
 |      int version due to the implicit bool conversion ambiguity of int as
 |      dimension
 |
 |      |
 |
 |      *Overload 5:*
 |      int version due to the implicit bool conversion ambiguity of int as
 |      dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  addIndex = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  add_c = add(self, n, x)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  add_replica(self, index)
 |      Alias for addIndex()
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, arg2, v)
 |      reconstructs from the first index
 |
 |  remove_replica(self, index)
 |      Alias for removeIndex()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |      faiss::Index API
 |      Query is partitioned into a slice for each sub-index
 |      split by ceil(n / #indices) for our sub-indices
 |
 |  syncWithSubIndexes(self)
 |      Synchronize the top-level index (IndexShards) with data in the
 |      sub-indices
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexReplicas(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ThreadedIndexBase:
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ThreadedIndexBase:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexResidualQuantizer in module faiss.swigfaiss

class IndexResidualQuantizer(IndexAdditiveQuantizer)
 |  IndexResidualQuantizer(*args)
 |
 |   Index based on a residual quantizer. Stored vectors are
 |  approximated by residual quantization codes.
 |  Can also be used as a codec
 |
 |  Method resolution order:
 |      IndexResidualQuantizer
 |      IndexAdditiveQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rq
 |      The residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizer:
 |
 |  aq
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexResidualQuantizer in module faiss.swigfaiss

class IndexResidualQuantizer(IndexAdditiveQuantizer)
 |  IndexResidualQuantizer(*args)
 |
 |   Index based on a residual quantizer. Stored vectors are
 |  approximated by residual quantization codes.
 |  Can also be used as a codec
 |
 |  Method resolution order:
 |      IndexResidualQuantizer
 |      IndexAdditiveQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rq
 |      The residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFlatCodes
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from faiss.swigfaiss.IndexFlatCodes
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm) from faiss.swigfaiss.IndexFlatCodes
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.IndexFlatCodes
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFlatCodes
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizer:
 |
 |  aq
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexResidualQuantizerFastScan in module faiss.swigfaiss

class IndexResidualQuantizerFastScan(IndexAdditiveQuantizerFastScan)
 |  IndexResidualQuantizerFastScan(*args)
 |
 |   Index based on a residual quantizer. Stored vectors are
 |  approximated by residual quantization codes.
 |  Can also be used as a codec
 |
 |  Method resolution order:
 |      IndexResidualQuantizerFastScan
 |      IndexAdditiveQuantizerFastScan
 |      IndexFastScan
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |      :type metric: int, optional
 |      :param metric:  metric type
 |      :type search_type: int, optional
 |      :param search_type: AQ search type
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexResidualQuantizerFastScan(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  rq
 |      The residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexAdditiveQuantizerFastScan:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexFastScan
 |       Add vectors to the index
 |
 |      :type n: int
 |      :param n:  number of vectors to add
 |      :type x: float
 |      :param x:  vectors to add (n * d)
 |
 |  compute_codes(self, codes, n, x)
 |       Compute codes for vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  output codes
 |      :type n: int
 |      :param n:      number of vectors to encode
 |      :type x: float
 |      :param x:      vectors to encode (n * d)
 |
 |  compute_float_LUT(self, lut, n, x, context)
 |       Compute floating-point lookup table for distance computation
 |
 |      :type lut: float
 |      :param lut:          output lookup table
 |      :type n: int
 |      :param n:            number of query vectors
 |      :type x: float
 |      :param x:            query vectors (n * d)
 |      :type context: :py:class:`FastScanDistancePostProcessing`
 |      :param context:      processing context containing all processors
 |
 |  estimate_norm_scale(self, n, x)
 |
 |  fast_scan_code_size(self)
 |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
 |
 |  init(self, *args)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons) from faiss.swigfaiss.IndexFastScan
 |       Reconstruct a vector from its code
 |
 |      :type key: int
 |      :param key:     index of vector to reconstruct
 |      :type recons: float
 |      :param recons:  output reconstructed vector
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.IndexFastScan
 |       Remove vectors by ID selector
 |
 |      :type sel: :py:class:`IDSelector`
 |      :param sel:  selector defining which vectors to remove
 |      :rtype: int
 |      :return: number of vectors removed
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       Decode a set of vectors.
 |
 |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
 |             contiguous. But this method requires a contiguous representation.
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * code_size
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.IndexFastScan
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
 |
 |  aq
 |
 |  max_train_points
 |
 |  norm_scale
 |
 |  rescale_norm
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFastScan:
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       Check if another index is compatible for merging
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to check compatibility with
 |
 |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
 |
 |  get_CodePacker(self)
 |       Get the code packer for this index
 |
 |      :rtype: :py:class:`CodePacker`
 |      :return: pointer to the code packer
 |
 |  get_block_stride(self)
 |       Get stride in bytes between consecutive SIMD blocks.
 |
 |      Derived from get_CodePacker()->block_size so that there is a
 |      single source of truth for the block layout.
 |
 |      :rtype: int
 |      :return: stride in bytes
 |
 |  init_fastscan(self, d, M, nbits, metric, bbs)
 |       Initialize the fast scan index
 |
 |      :type d: int
 |      :param d:         dimensionality of vectors
 |      :type M: int
 |      :param M:         number of subquantizers
 |      :type nbits: int
 |      :param nbits:     number of bits per subquantizer
 |      :type metric: int
 |      :param metric:    distance metric to use
 |      :type bbs: int
 |      :param bbs:       block size for SIMD processing
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       Merge another index into this one
 |
 |      :type otherIndex: :py:class:`Index`
 |      :param otherIndex:  index to merge from
 |      :type add_id: int, optional
 |      :param add_id:      ID offset to add to merged vectors
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      standalone codes interface (but the codes are flattened)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFastScan:
 |
 |  M
 |
 |  M2
 |
 |  bbs
 |
 |  code_size
 |
 |  codes
 |
 |  implem
 |
 |  ksub
 |
 |  nbits
 |
 |  ntotal2
 |
 |  orig_codes
 |
 |  qbs
 |
 |  skip
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRowwiseMinMax in module faiss.swigfaiss

class IndexRowwiseMinMax(IndexRowwiseMinMaxBase)
 |  IndexRowwiseMinMax(*args)
 |
 |  Stores scaling coefficients as fp32 values.
 |
 |  Method resolution order:
 |      IndexRowwiseMinMax
 |      IndexRowwiseMinMaxBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x) from faiss.swigfaiss.IndexRowwiseMinMaxBase
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None) from faiss.swigfaiss.IndexRowwiseMinMaxBase
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  train_inplace = replacement_train_inplace(self, x) from faiss.class_wrappers.handle_IndexRowwiseMinMax.<locals>
 |      Trains the index on a representative set of vectors inplace.
 |      The index must be trained before vectors can be added to it.
 |
 |      This call WILL change the values in the input array, because
 |      of two scaling procedures being performed inplace.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_inplace_c = train_inplace(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRowwiseMinMax(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexRowwiseMinMaxBase:
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexRowwiseMinMaxBase:
 |
 |  index
 |      sub-index
 |
 |  own_fields
 |      whether the subindex needs to be freed in the destructor.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRowwiseMinMaxBase in module faiss.swigfaiss

class IndexRowwiseMinMaxBase(Index)
 |  IndexRowwiseMinMaxBase(*args, **kwargs)
 |
 |   Index wrapper that performs rowwise normalization to [0,1], preserving
 |   the coefficients. This is a vector codec index only.
 |
 |   Basically, this index performs a rowwise scaling to [0,1] of every row
 |   in an input dataset before calling subindex::train() and
 |   subindex::sa_encode(). sa_encode() call stores the scaling coefficients
 |    (scaler and minv) in the very beginning of every output code. The format:
 |       [scaler][minv][subindex::sa_encode() output]
 |   The de-scaling in sa_decode() is done using:
 |       output_rescaled = scaler * output + minv
 |
 |   An additional ::train_inplace() function is provided in order to do
 |   an inplace scaling before calling subindex::train() and, thus, avoiding
 |   the cloning of the input dataset, but modifying the input dataset because
 |   of the scaling and the scaling back. It is up to user to call
 |   this function instead of ::train()
 |
 |   Derived classes provide different data types for scaling coefficients.
 |   Currently, versions with fp16 and fp32 scaling coefficients are available.
 |  fp16 version adds 4 extra bytes per encoded vector
 |  fp32 version adds 8 extra bytes per encoded vector
 |   Provides base functions for rowwise normalizing indices.
 |
 |  Method resolution order:
 |      IndexRowwiseMinMaxBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train_inplace(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRowwiseMinMaxBase(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  index
 |      sub-index
 |
 |  own_fields
 |      whether the subindex needs to be freed in the destructor.
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexRowwiseMinMaxFP16 in module faiss.swigfaiss

class IndexRowwiseMinMaxFP16(IndexRowwiseMinMaxBase)
 |  IndexRowwiseMinMaxFP16(*args)
 |
 |  Stores scaling coefficients as fp16 values.
 |
 |  Method resolution order:
 |      IndexRowwiseMinMaxFP16
 |      IndexRowwiseMinMaxBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  train_inplace = replacement_train_inplace(self, x) from faiss.class_wrappers.handle_IndexRowwiseMinMax.<locals>
 |      Trains the index on a representative set of vectors inplace.
 |      The index must be trained before vectors can be added to it.
 |
 |      This call WILL change the values in the input array, because
 |      of two scaling procedures being performed inplace.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_inplace_c = train_inplace(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexRowwiseMinMaxFP16(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexRowwiseMinMaxBase:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexRowwiseMinMaxBase:
 |
 |  index
 |      sub-index
 |
 |  own_fields
 |      whether the subindex needs to be freed in the destructor.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexScalarQuantizer in module faiss.swigfaiss

class IndexScalarQuantizer(IndexFlatCodes)
 |  IndexScalarQuantizer(*args)
 |
 |  Flat index built on a scalar quantizer.
 |
 |  Method resolution order:
 |      IndexScalarQuantizer
 |      IndexFlatCodes
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type qtype: int
 |      :param qtype:  type of scalar quantizer (e.g., QT_4bit)
 |      :type metric: int, optional
 |      :param metric: distance metric used for search (default: METRIC_L2)
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  get_FlatCodesDistanceComputer(self)
 |       a FlatCodesDistanceComputer offers a distance_to_code method
 |
 |      The default implementation explicitly decodes the vector with sa_decode.
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexScalarQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  sq
 |      Used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexFlatCodes:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      default add uses sa_encode
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  get_CodePacker(self)
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  permute_entries_c = permute_entries(self, perm)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       remove some ids. NB that because of the structure of the
 |      index, the semantics of this operation are
 |      different from the usual ones: the new ids are shifted
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexFlatCodes:
 |
 |  code_size
 |
 |  codes
 |      encoded dataset, size ntotal * code_size
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexShards in module faiss.swigfaiss

class IndexShards(ThreadedIndexBase)
 |  IndexShards(*args)
 |
 |  Index that concatenates the results from several sub-indexes
 |
 |  Method resolution order:
 |      IndexShards
 |      ThreadedIndexBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |
 |      The dimension that all sub-indices must share will be the dimension of
 |      the first sub-index added
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :type successive_ids: boolean, optional
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 2:*
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :type successive_ids: boolean, optional
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 3:*
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 4:*
 |
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 5:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |      |
 |
 |      *Overload 6:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |      |
 |
 |      *Overload 7:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      supported only for sub-indices that implement add_with_ids
 |
 |  add_shard = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |      Cases (successive_ids, xids):
 |      - true, non-NULL       ERROR: it makes no sense to pass in ids and
 |                             request them to be shifted
 |      - true, NULL           OK: but should be called only once (calls add()
 |                             on sub-indexes).
 |      - false, non-NULL      OK: will call add_with_ids with passed in xids
 |                             distributed evenly over shards
 |      - false, NULL          OK: will call add_with_ids on each sub-index,
 |                             starting at ntotal
 |
 |  remove_shard(self, index)
 |      Alias for removeIndex()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  syncWithSubIndexes(self)
 |      Synchronize the top-level index (IndexShards) with data in the
 |      sub-indices
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexShards(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  successive_ids
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ThreadedIndexBase:
 |
 |  addIndex(self, index)
 |      override an index that is managed by ourselves.
 |      WARNING: once an index is added, it becomes unsafe to touch it from any
 |      other thread than that on which is managing it, until we are shut
 |      down. Use runOnIndex to perform work on it instead.
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ThreadedIndexBase:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class IndexShardsIVF in module faiss.swigfaiss

class IndexShardsIVF(IndexShards, Level1Quantizer)
 |  IndexShardsIVF(quantizer, nlist, threaded=False, successive_ids=True)
 |
 |  IndexShards with a common coarse quantizer. All the indexes added should be
 |  IndexIVFInterface indexes so that the search_precomputed can be called.
 |
 |  Method resolution order:
 |      IndexShardsIVF
 |      IndexShards
 |      ThreadedIndexBase
 |      Index
 |      Level1Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, quantizer, nlist, threaded=False, successive_ids=True)
 |      *Overload 1:*
 |
 |      The dimension that all sub-indices must share will be the dimension of
 |      the first sub-index added
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :type successive_ids: boolean, optional
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 2:*
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :type successive_ids: boolean, optional
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 3:*
 |
 |      :type threaded: boolean, optional
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 4:*
 |
 |      :param threaded:     do we use one thread per sub_index or do
 |                              queries sequentially?
 |      :param successive_ids: should we shift the returned ids by
 |                              the size of each sub-index or return them
 |                              as they are?
 |
 |      |
 |
 |      *Overload 5:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |      |
 |
 |      *Overload 6:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |      |
 |
 |      *Overload 7:*
 |       int version due to the implicit bool conversion ambiguity of int as
 |       dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  addIndex(self, index)
 |      override an index that is managed by ourselves.
 |      WARNING: once an index is added, it becomes unsafe to touch it from any
 |      other thread than that on which is managing it, until we are shut
 |      down. Use runOnIndex to perform work on it instead.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexShardsIVF(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexShards:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      supported only for sub-indices that implement add_with_ids
 |
 |  add_shard = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
 |
 |  remove_shard(self, index)
 |      Alias for removeIndex()
 |
 |  syncWithSubIndexes(self)
 |      Synchronize the top-level index (IndexShards) with data in the
 |      sub-indices
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexShards:
 |
 |  successive_ids
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ThreadedIndexBase:
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ThreadedIndexBase:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Level1Quantizer:
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Level1Quantizer:
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer

Python Library Documentation: class IndexSplitVectors in module faiss.swigfaiss

class IndexSplitVectors(Index)
 |  IndexSplitVectors(d, threaded=False)
 |
 |   splits input vectors in segments and assigns each segment to a sub-index
 |  used to distribute a MultiIndexQuantizer
 |
 |  Method resolution order:
 |      IndexSplitVectors
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, d, threaded=False)
 |      sum of dimensions seen so far
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |
 |  add_sub_index(self, arg2)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  sync_with_sub_indexes(self)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IndexSplitVectors(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  own_fields
 |
 |  sub_indexes
 |
 |  sum_d
 |
 |  thisown
 |      The membership flag
 |
 |  threaded
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class Int16Vector in module faiss.swigfaiss

class Int16Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int16Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Int32Tensor2D in module faiss.swigfaiss

class Int32Tensor2D(builtins.object)
 |  Int32Tensor2D(*args)
 |
 |  Implements a few neural net layers, mainly to support QINCo
 |
 |  Methods defined here:
 |
 |  __iadd__(self, arg2)
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Tensor2D.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  column(self, j)
 |      get column #j as a 1-column Tensor2D
 |
 |  data(self, *args)
 |
 |  numel(self)
 |
 |  numpy(self) from faiss.class_wrappers.handle_Tensor2D.<locals>
 |
 |  original_init = __init__(self, n0, n1, data=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int32Tensor2D(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  shape
 |
 |  thisown
 |      The membership flag
 |
 |  v

Python Library Documentation: class Int32Vector in module faiss.swigfaiss

class Int32Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Int32VectorVector in module faiss.swigfaiss

class Int32VectorVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int32VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Int64Vector in module faiss.swigfaiss

class Int64Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int64Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Int64VectorVector in module faiss.swigfaiss

class Int64VectorVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int64VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class Int8Vector in module faiss.swigfaiss

class Int8Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Int8Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IntVector in module faiss.array_conversions

class IntVector(faiss.swigfaiss.Int32Vector)
 |  IntVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      IntVector
 |      faiss.swigfaiss.Int32Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Int32Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Int32Vector:
 |
 |  __swig_destroy__ = delete_Int32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Int32Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class InterruptCallback in module faiss.swigfaiss

class InterruptCallback(builtins.object)
 |  InterruptCallback(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  want_interrupt(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InterruptCallback(...)
 |
 |  check()
 |       check if:
 |      - an interrupt callback is set
 |      - the callback returns true
 |      if this is the case, then throw an exception. Should not be called
 |      from multiple threads.
 |
 |  clear_instance()
 |
 |  get_period_hint(flops)
 |       assuming each iteration takes a certain number of flops, what
 |      is a reasonable interval to check for interrupts?
 |
 |  is_interrupted()
 |      same as check() but return true if is interrupted instead of
 |      throwing. Can be called from multiple threads.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class IntersectionCriterion in module faiss.swigfaiss

class IntersectionCriterion(AutoTuneCriterion)
 |  IntersectionCriterion(nq, R)
 |
 |  Method resolution order:
 |      IntersectionCriterion
 |      AutoTuneCriterion
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, nq, R)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  evaluate(self, D, I)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_IntersectionCriterion(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  R
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AutoTuneCriterion:
 |
 |  evaluate_c = evaluate(self, D, I)
 |       Evaluate the criterion.
 |
 |      :type D: float
 |      :param D:  size nq * nnn
 |      :type I: int
 |      :param I:  size nq * nnn
 |      :rtype: float
 |      :return: the criterion, between 0 and 1. Larger is better.
 |
 |  set_groundtruth = replacement_set_groundtruth(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
 |
 |  set_groundtruth_c = set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
 |       Initializes the gt_D and gt_I vectors. Must be called before evaluating
 |
 |      :type gt_D_in: float
 |      :param gt_D_in:  size nq * gt_nnn
 |      :type gt_I_in: int
 |      :param gt_I_in:  size nq * gt_nnn
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AutoTuneCriterion:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  gt_D
 |      Ground-truth distances (size nq * gt_nnn)
 |
 |  gt_I
 |      Ground-truth indexes (size nq * gt_nnn)
 |
 |  gt_nnn
 |      nb of GT NNs required to evaluate criterion
 |
 |  nnn
 |      nb of NNs that the query should request
 |
 |  nq
 |      nb of queries this criterion is evaluated on

Python Library Documentation: class InvertedListScanner in module faiss.swigfaiss

class InvertedListScanner(builtins.object)
 |  InvertedListScanner(*args, **kwargs)
 |
 |   Object that handles a query. The inverted lists to scan are
 |  provided externally. The object has a lot of state, but
 |  distance_to_code and scan_codes can be called in multiple
 |  threads
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  distance_to_code(self, code)
 |      compute a single query-to-code distance
 |
 |  iterate_codes(self, iterator, distances, labels, k, list_size)
 |
 |  iterate_codes_range(self, iterator, radius, result, list_size)
 |
 |  scan_codes(self, *args)
 |       scan a set of codes, compute distances to current query, and
 |      update heap of results if necessary. Default implementation
 |      calls distance_to_code.
 |
 |      :type n: int
 |      :param n:          number of codes to scan
 |      :type codes: uint8_t
 |      :param codes:      codes to scan (n * code_size)
 |      :type ids: int
 |      :param ids:        corresponding ids (ignored if store_pairs)
 |      :type distances: float
 |      :param distances:  heap distances (size k)
 |      :type labels: int
 |      :param labels:     heap labels (size k)
 |      :type k: int
 |      :param k:          heap size
 |      :rtype: int
 |      :return: number of heap updates performed
 |
 |  scan_codes_range(self, n, codes, ids, radius, result)
 |       scan a set of codes, compute distances to current query and
 |      update results if distances are below radius
 |
 |      (default implementation fails)
 |
 |  set_list(self, list_no, coarse_dis)
 |      following codes come from this inverted list
 |
 |  set_query(self, query_vector)
 |      from now on we handle this query.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InvertedListScanner(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      used in default implementation of scan_codes
 |
 |  keep_max
 |      keep maximum instead of minimum
 |
 |  list_no
 |      remember current list
 |
 |  sel
 |      search in this subset of ids
 |
 |  store_pairs
 |      store positions in invlists rather than labels
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class InvertedListScannerStats in module faiss.swigfaiss

class InvertedListScannerStats(builtins.object)
 |  Per-list statistics returned by inverted-list scanners.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InvertedListScannerStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  nheap_updates
 |      Number of heap updates.
 |
 |  scan_cnt
 |      Number of distances computed after IDSelector filtering.
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class InvertedLists in module faiss.swigfaiss

class InvertedLists(builtins.object)
 |  InvertedLists(*args, **kwargs)
 |
 |   Table of inverted lists
 |  multithreading rules:
 |  - concurrent read accesses are allowed
 |  - concurrent update accesses are allowed
 |  - for resize and add_entries, only concurrent access to different lists
 |    are allowed
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  reset(self)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  thisown
 |      The membership flag
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class InvertedListsIOHook in module faiss.swigfaiss

class InvertedListsIOHook(builtins.object)
 |  InvertedListsIOHook(*args, **kwargs)
 |
 |   Callbacks to handle other types of InvertedList objects.
 |
 |  The callbacks should be registered with add_callback before calling
 |  read_index or read_InvertedLists. The callbacks for
 |  OnDiskInvertedLists are registrered by default. The invlist type is
 |  identified by:
 |
 |  - the key (a fourcc) at read time
 |  - the class name (as given by typeid.name) at write time
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  read(self, f, io_flags)
 |      called when the fourcc matches this class's fourcc
 |
 |  read_ArrayInvertedLists(self, f, io_flags, nlist, code_size, sizes)
 |       read from a ArrayInvertedLists into this invertedlist type.
 |      For this to work, the callback has to be enabled and the io_flag has to
 |      be set to IO_FLAG_SKIP_IVF_DATA | (16 upper bits of the fourcc)
 |
 |      (default implementation fails)
 |
 |  write(self, ils, f)
 |      write the index to the IOWriter (including the fourcc)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InvertedListsIOHook(...)
 |
 |  add_callback(arg1)
 |
 |  lookup(h)
 |
 |  lookup_classname(classname)
 |
 |  print_callbacks()
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  classname
 |      typeid.name
 |
 |  key
 |      string version of the fourcc
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class InvertedListsIterator in module faiss.swigfaiss

class InvertedListsIterator(builtins.object)
 |  InvertedListsIterator(*args, **kwargs)
 |
 |  Definition of inverted lists + a few common classes that implement
 |  the interface.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_id_and_codes(self)
 |
 |  is_available(self)
 |
 |  next(self)
 |
 |  on_distance_computed(self, arg2, arg3)
 |      Called from iterate_codes after distance computation for the vector
 |      returned by the most recent get_id_and_codes(). Default: no-op.
 |      Only invoked when has_search_callbacks_ is true.
 |
 |  on_heap_changed(self, arg2, arg3)
 |      Called from iterate_codes when a vector replaces the current worst
 |      in the top-K heap. evicted_id is the displaced entry. Default: no-op.
 |      Only invoked when has_search_callbacks_ is true.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InvertedListsIterator(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  has_search_callbacks_
 |      When true, iterate_codes will invoke on_distance_computed() and
 |      on_heap_changed() via virtual dispatch. When false (the default),
 |      iterate_codes skips the callbacks entirely — the guard branch is
 |      perfectly predicted and costs ~0 cycles, so non-callback users
 |      pay no overhead. Derived classes that override the callbacks
 |      should set this to true in their constructor.
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class InvertedListsPtrVector in module faiss.swigfaiss

class InvertedListsPtrVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_InvertedListsPtrVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Kmeans in module faiss.extra_wrappers

class Kmeans(builtins.object)
 |  Kmeans(d, k, **kwargs)
 |
 |  Object that performs k-means clustering and manages the centroids.
 |  The `Kmeans` class is essentially a wrapper around the C++ `Clustering` object.
 |
 |  Parameters
 |  ----------
 |  d : int
 |     dimension of the vectors to cluster
 |  k : int
 |     number of clusters
 |  gpu: bool or int, optional
 |     False: don't use GPU
 |     True: use all GPUs
 |     number: use this many GPUs
 |  progressive_dim_steps:
 |      use a progressive dimension clustering (with that number of steps)
 |
 |  Subsequent parameters are fields of the Clustring object. The most important are:
 |
 |  niter: int, optional
 |     clustering iterations
 |  nredo: int, optional
 |     redo clustering this many times and keep best
 |  verbose: bool, optional
 |  spherical: bool, optional
 |     do we want normalized centroids?
 |  int_centroids: bool, optional
 |     round centroids coordinates to integer
 |  seed: int, optional
 |     seed for the random number generator
 |  init_method: ClusteringInitMethod, optional
 |     centroid initialization method:
 |     - ClusteringInitMethod_RANDOM: uniform random sampling (default)
 |     - ClusteringInitMethod_KMEANS_PLUS_PLUS: k-means++ D²-weighted sampling,
 |       selects centroids with probability proportional to squared distance
 |       from existing centroids. Better quality but O(nkd) complexity.
 |     - ClusteringInitMethod_AFK_MC2: Assumption-Free K-MC², MCMC-based
 |       approximation using Metropolis-Hastings. Good quality with lower
 |       complexity than k-means++ for large k.
 |  afkmc2_chain_length: int, optional
 |     chain length for AFK-MC² initialization (default 50). Longer chains
 |     give better approximation to k-means++ but are slower.
 |
 |  Methods defined here:
 |
 |  __init__(self, d, k, **kwargs)
 |      d: input dimension, k: nb of centroids. Additional
 |      parameters are passed on the ClusteringParameters object,
 |      including niter=25, verbose=False, spherical = False
 |
 |  assign(self, x)
 |
 |  reset(self, k=None)
 |      prepare k-means object to perform a new clustering, possibly
 |      with another number of centroids
 |
 |  set_index(self)
 |
 |  train(self, x, weights=None, init_centroids=None)
 |      Perform k-means clustering.
 |      On output of the function call:
 |
 |      - the centroids are in the centroids field of size (`k`, `d`).
 |
 |      - the objective value at each iteration is in the array obj (size `niter`)
 |
 |      - detailed optimization statistics are in the array iteration_stats.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, d), `dtype` must be float32 and n should
 |          be larger than the number of clusters `k`.
 |      weights : array_like
 |          weight associated to each vector, shape `n`
 |      init_centroids : array_like
 |          initial set of centroids, shape (n, d)
 |
 |      Returns
 |      -------
 |      final_obj: float
 |          final optimization objective
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class LSQTimer in module faiss.swigfaiss

class LSQTimer(builtins.object)
 |  A helper struct to count consuming time during training.
 |  It is NOT thread-safe.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, name, delta)
 |
 |  get(self, name)
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_LSQTimer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  t
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class LSQTimerScope in module faiss.swigfaiss

class LSQTimerScope(builtins.object)
 |  LSQTimerScope(timer, name)
 |
 |  Methods defined here:
 |
 |  __init__(self, timer, name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  finish(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_LSQTimerScope(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  finished
 |
 |  name
 |
 |  t0
 |
 |  thisown
 |      The membership flag
 |
 |  timer

Python Library Documentation: class Level1Quantizer in module faiss.swigfaiss

class Level1Quantizer(builtins.object)
 |  Level1Quantizer(*args)
 |
 |   Encapsulates a quantizer object for the IndexIVF
 |
 |  The class isolates the fields that are independent of the storage
 |  of the lists (especially training)
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  coarse_code_size(self)
 |      compute the number of bytes required to store list ids
 |
 |  decode_listno(self, code)
 |
 |  encode_listno(self, list_no, code)
 |
 |  train_q1(self, n, x, verbose, metric_type)
 |      Trains the quantizer and calls train_residual to train sub-quantizers
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Level1Quantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  clustering_index
 |      to override index used during clustering
 |
 |  cp
 |      to override default clustering params
 |
 |  nlist
 |      number of inverted lists
 |
 |  own_fields
 |      whether object owns the quantizer
 |
 |  quantizer
 |      quantizer that maps vectors to inverted lists
 |
 |  quantizer_trains_alone
 |      = 0: use the quantizer as index in a kmeans training
 |      = 1: just pass on the training set to the train() of the quantizer
 |      = 2: kmeans training on a flat index + add the centroids to the quantizer
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Linear in module faiss.swigfaiss

class Linear(builtins.object)
 |  Linear(*args)
 |
 |  minimal translation of nn.Linear
 |
 |  Methods defined here:
 |
 |  __call__(self, x)
 |      Call self as a function.
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Linear.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  from_array(self, array, bias=None) from faiss.class_wrappers.handle_Linear.<locals>
 |      copy weights from numpy array
 |
 |  from_torch(self, linear) from faiss.class_wrappers.handle_Linear.<locals>
 |      copy weights from torch.Linear
 |
 |  original_init = __init__(self, in_features, out_features, bias=True)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Linear(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  bias
 |
 |  in_features
 |
 |  out_features
 |
 |  thisown
 |      The membership flag
 |
 |  weight

Python Library Documentation: class LinearTransform in module faiss.swigfaiss

class LinearTransform(VectorTransform)
 |  LinearTransform(din=0, dout=0, have_bias_in=False)
 |
 |   Generic linear transformation, with bias term applied on output
 |  y = A * x + b
 |
 |  Method resolution order:
 |      LinearTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, din=0, dout=0, have_bias_in=False)
 |      both d_in > d_out and d_out < d_in are supported
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |      same as apply, but result is pre-allocated
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  print_if_verbose(self, name, mat, n, d)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      works only if is_orthonormal
 |
 |  set_is_orthonormal(self)
 |      compute A^T * A to set the is_orthonormal flag
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x) from faiss.swigfaiss.VectorTransform
 |       Perform training on a representative set of vectors. Does
 |      nothing by default.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  transform_transpose(self, n, y, x)
 |      compute x = A^T * (x - b)
 |      is reverse transform if A has orthonormal lines
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_LinearTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  A
 |      Transformation matrix, size d_out * d_in
 |
 |  b
 |      bias vector, size d_out
 |
 |  have_bias
 |
 |  is_orthonormal
 |      whether to use the bias term
 |       check if matrix A is orthonormal (enables reverse_transform)
 |
 |  thisown
 |      The membership flag
 |
 |  verbose
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class LocalSearchCoarseQuantizer in module faiss.swigfaiss

class LocalSearchCoarseQuantizer(AdditiveCoarseQuantizer)
 |  LocalSearchCoarseQuantizer(*args)
 |
 |  Method resolution order:
 |      LocalSearchCoarseQuantizer
 |      AdditiveCoarseQuantizer
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_LocalSearchCoarseQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  lsq
 |      The residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveCoarseQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      N/A
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids) from faiss.swigfaiss.Index
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.Index
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1) from faiss.swigfaiss.Index
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.Index
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons) from faiss.swigfaiss.Index
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.Index
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.Index
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  reset(self)
 |      N/A
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.Index
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.Index
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None) from faiss.swigfaiss.Index
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveCoarseQuantizer:
 |
 |  aq
 |
 |  centroid_norms
 |      norms of centroids, useful for knn-search
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class LocalSearchQuantizer in module faiss.swigfaiss

class LocalSearchQuantizer(AdditiveQuantizer)
 |  LocalSearchQuantizer(*args)
 |
 |   Implementation of LSQ/LSQ++ described in the following two papers:
 |
 |  Revisiting additive quantization
 |  Julieta Martinez, et al. ECCV 2016
 |
 |  LSQ++: Lower running time and higher recall in multi-codebook quantization
 |  Julieta Martinez, et al. ECCV 2018
 |
 |  This implementation is mostly translated from the Julia implementations
 |  by Julieta Martinez:
 |  (https://github.com/una-dinosauria/local-search-quantization,
 |   https://github.com/una-dinosauria/Rayuela.jl)
 |
 |  The trained codes are stored in `codebooks` which is called
 |  `centroids` in PQ and RQ.
 |
 |  Method resolution order:
 |      LocalSearchQuantizer
 |      AdditiveQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_binary_terms(self, binaries)
 |       Compute binary terms
 |
 |      :type binaries: float
 |      :param binaries: binary terms, size M * M * K * K
 |
 |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |      :type n: int
 |      :param n:      number of vectors
 |      :type centroids: float, optional
 |      :param centroids:  centroids to be added to x, size n * d
 |
 |  compute_unary_terms(self, x, unaries, n)
 |       Compute unary terms
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       vectors to encode, size n * d
 |      :type unaries: float
 |      :param unaries: unary terms, size n * M * K
 |
 |  evaluate(self, codes, x, n, objs=None)
 |       Helper function to compute reconstruction error
 |
 |      :type codes: int
 |      :param codes: encoded codes, size n * M
 |      :type x: float
 |      :param x:     vectors to encode, size n * d
 |      :type n: int
 |      :param n:     number of vectors
 |      :type objs: float, optional
 |      :param objs:  if it is not null, store reconstruction
 |                              error of each vector into it, size n
 |
 |  icm_encode(self, codes, x, n, ils_iters, gen)
 |       Encode vectors given codebooks using iterative conditional mode (icm).
 |
 |      :type codes: int
 |      :param codes:     output codes, size n * M
 |      :type x: float
 |      :param x:         vectors to encode, size n * d
 |      :type n: int
 |      :param n:         number of vectors
 |      :type ils_iters: int
 |      :param ils_iters: number of iterations of iterative local search
 |
 |  icm_encode_impl(self, codes, x, unaries, gen, n, ils_iters, verbose)
 |
 |  icm_encode_step(self, codes, unaries, binaries, n, n_iters)
 |
 |  perturb_codebooks(self, T, stddev, gen)
 |       Add some perturbation to codebooks
 |
 |      :type T: float
 |      :param T:         temperature of simulated annealing
 |      :type stddev: std::vector< float >
 |      :param stddev:    standard deviations of each dimension in training data
 |
 |  perturb_codes(self, codes, n, gen)
 |       Add some perturbation to codes
 |
 |      :type codes: int
 |      :param codes: codes to be perturbed, size n * M
 |      :type n: int
 |      :param n:     number of vectors
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  update_codebooks(self, x, codes, n)
 |       Update codebooks given encodings
 |
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |      :type codes: int
 |      :param codes:  encoded training vectors, size n * M
 |      :type n: int
 |      :param n:      number of vectors
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_LocalSearchQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  K
 |      number of codes per codebook
 |
 |  chunk_size
 |      nb of vectors to encode at a time
 |
 |  encode_ils_iters
 |      iterations of local search in encoding
 |
 |  icm_encoder_factory
 |
 |  icm_iters
 |      number of iterations in icm
 |
 |  lambd
 |      regularization factor
 |
 |  nperts
 |      number of perturbation in each code
 |      if non-NULL, use this encoder to encode (owned by the object)
 |
 |  p
 |      temperature factor
 |
 |  random_seed
 |      seed for random generator
 |
 |  thisown
 |      The membership flag
 |
 |  train_ils_iters
 |      iterations of local search in training
 |
 |  train_iters
 |      number of iterations in training
 |
 |  update_codebooks_with_double
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveQuantizer:
 |
 |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
 |       Compute inner-product look-up tables. Used in the centroid search
 |      functions.
 |
 |      :type xq: float
 |      :param xq:     query vector, size (n, d)
 |      :type LUT: float
 |      :param LUT:    look-up table, size (n, total_codebook_size)
 |      :type alpha: float, optional
 |      :param alpha:  compute alpha * inner-product
 |      :type ld_lut: int, optional
 |      :param ld_lut:  leading dimension of LUT
 |
 |  compute_centroid_norms(self, norms)
 |       For L2 search we need the L2 norms of the centroids
 |
 |      :type norms: float
 |      :param norms:    output norms table, size total_codebook_size
 |
 |  compute_codebook_tables(self)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_64bit(self, n, x)
 |      decoding function for a code in a 64-bit word
 |
 |  decode_c = decode(self, codes, x, n)
 |       Decode a set of vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  decode_qcint(self, c)
 |      decode norm by non-uniform scalar quantization
 |
 |  decode_unpacked(self, codes, x, n, ld_codes=-1)
 |       Decode a set of vectors in non-packed format
 |
 |      :type codes: int
 |      :param codes:  codes to decode, size n * ld_codes
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  encode_norm(self, norm)
 |      encode a norm into norm_bits bits
 |
 |  encode_qcint(self, x)
 |      encode norm by non-uniform scalar quantization
 |
 |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
 |      Exact L2 search, with precomputed norms
 |
 |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
 |      exact IP search
 |
 |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
 |       pack a series of code to bit-compact format
 |
 |      :type codes: int
 |      :param codes:        codes to be packed, size n * code_size
 |      :type packed_codes: uint8_t
 |      :param packed_codes: output bit-compact codes
 |      :type ld_codes: int, optional
 |      :param ld_codes:     leading dimension of codes
 |      :type norms: float, optional
 |      :param norms:        norms of the vectors (size n). Will be computed if
 |                              needed but not provided
 |      :type centroids: float, optional
 |      :param centroids:    centroids to be added to x, size n * d
 |
 |  set_derived_values(self)
 |      Train the norm quantizer
 |
 |  train_norm(self, n, norms)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveQuantizer:
 |
 |  M
 |      number of codebooks
 |
 |  centroid_norms
 |      norms of all codebook entries (size total_codebook_size)
 |
 |  codebook_cross_products
 |      dot products of all codebook entries with the previous codebooks
 |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
 |
 |  codebook_offsets
 |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
 |      in the codebooks table of size total_codebook_size by d
 |
 |  codebooks
 |      codebooks
 |
 |  is_trained
 |      is trained or not
 |
 |  max_mem_distances
 |      norms and distance matrixes with beam search can get large, so use this
 |      to control for the amount of memory that can be allocated
 |
 |  nbits
 |      bits for each step
 |
 |  norm_bits
 |      bits allocated for the norms
 |
 |  norm_max
 |
 |  norm_min
 |      min/max for quantization of norms
 |
 |  norm_tabs
 |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
 |      store norms of codebook entries for 4-bit fastscan
 |
 |  only_8bit
 |      are all nbits = 8 (use faster decoder)
 |
 |  qnorm
 |      store and search norms
 |
 |  search_type
 |      Also determines what's in the codes
 |
 |  tot_bits
 |      total number of bits (indexes + norms)
 |
 |  total_codebook_size
 |      size of the codebook in vectors
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from AdditiveQuantizer:
 |
 |  ST_LUT_nonorm = 1
 |
 |  ST_count = 10
 |
 |  ST_decompress = 0
 |
 |  ST_norm_cqint4 = 7
 |
 |  ST_norm_cqint8 = 6
 |
 |  ST_norm_float = 3
 |
 |  ST_norm_from_LUT = 2
 |
 |  ST_norm_lsq2x4 = 8
 |
 |  ST_norm_qint4 = 5
 |
 |  ST_norm_qint8 = 4
 |
 |  ST_norm_rq2x4 = 9
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class LongLongVector in module faiss.array_conversions

class LongLongVector(faiss.swigfaiss.Int64Vector)
 |  LongLongVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      LongLongVector
 |      faiss.swigfaiss.Int64Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Int64Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Int64Vector:
 |
 |  __swig_destroy__ = delete_Int64Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Int64Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class LongVector in module faiss.array_conversions

class LongVector(faiss.swigfaiss.Int32Vector)
 |  LongVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      LongVector
 |      faiss.swigfaiss.Int32Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Int32Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Int32Vector:
 |
 |  __swig_destroy__ = delete_Int32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Int32Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class LongVectorVector in module faiss.array_conversions

class LongVectorVector(faiss.swigfaiss.Int32VectorVector)
 |  LongVectorVector(*args, **kwargs)
 |
 |  Method resolution order:
 |      LongVectorVector
 |      faiss.swigfaiss.Int32VectorVector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.Int32VectorVector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.Int32VectorVector:
 |
 |  __swig_destroy__ = delete_Int32VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.Int32VectorVector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class MapInt64ToInt64 in module faiss.extra_wrappers

class MapInt64ToInt64(builtins.object)
 |  MapInt64ToInt64(capacity)
 |
 |  Methods defined here:
 |
 |  __init__(self, capacity)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  add(self, keys, vals)
 |
 |  lookup(self, keys)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class MapLong2Long in module faiss.swigfaiss

class MapLong2Long(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add = replacement_map_add(self, keys, vals) from faiss.class_wrappers.handle_MapLong2Long.<locals>
 |
 |  add_c = add(self, n, keys, vals)
 |
 |  search(self, key)
 |
 |  search_multiple = replacement_map_search_multiple(self, keys) from faiss.class_wrappers.handle_MapLong2Long.<locals>
 |
 |  search_multiple_c = search_multiple(self, n, keys, vals)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MapLong2Long(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  map
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class MappedFileIOReader in module faiss.swigfaiss

class MappedFileIOReader(IOReader)
 |  MappedFileIOReader(owner)
 |
 |  Method resolution order:
 |      MappedFileIOReader
 |      IOReader
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, owner)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  filedescriptor(self)
 |
 |  mmap(self, ptr, size, nitems)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MappedFileIOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  mmap_owner
 |
 |  pos
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOReader:
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOReader:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class MaskedInvertedLists in module faiss.swigfaiss

class MaskedInvertedLists(ReadOnlyInvertedLists)
 |  MaskedInvertedLists(il0_in, il1_in)
 |
 |   use the first inverted lists if they are non-empty otherwise use the second
 |
 |  This is useful if il1 has a few inverted lists that are too long,
 |  and that il0 has replacement lists for those, with empty lists for
 |  the others.
 |
 |  Method resolution order:
 |      MaskedInvertedLists
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, il0_in, il1_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaskedInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  il0
 |
 |  il1
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ReadOnlyInvertedLists:
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class MatrixStats in module faiss.swigfaiss

class MatrixStats(builtins.object)
 |  MatrixStats(m)
 |
 |   Reports some statistics on a dataset and comments on them.
 |
 |  It is a class rather than a function so that all stats can also be
 |  accessed from code
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, m) from faiss.class_wrappers.handle_MatrixStats.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  do_comment(self, fmt)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MatrixStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  buf
 |
 |  comments
 |
 |  d
 |
 |  hash_value
 |
 |  max_norm2
 |
 |  min_norm2
 |
 |  n
 |
 |  n0
 |
 |  n_collision
 |
 |  n_valid
 |
 |  nbuf
 |
 |  occurrences
 |
 |  per_dim_stats
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class MaybeOwnedVectorFloat32 in module faiss.swigfaiss

class MaybeOwnedVectorFloat32(builtins.object)
 |  MaybeOwnedVectorFloat32(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, *args)
 |
 |  begin(self, *args)
 |
 |  byte_size(self)
 |
 |  clear(self)
 |
 |  data(self, *args)
 |
 |  end(self, *args)
 |
 |  erase(self, begin, end)
 |
 |  resize(self, *args)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorFloat32(...)
 |
 |  create_view(address, n_elements, owner)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  c_ptr
 |
 |  c_size
 |
 |  is_owned
 |
 |  owned_data
 |
 |  owner
 |
 |  thisown
 |      The membership flag
 |
 |  view_data
 |
 |  view_size

Python Library Documentation: class MaybeOwnedVectorFloat32Vector in module faiss.swigfaiss

class MaybeOwnedVectorFloat32Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorFloat32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class MaybeOwnedVectorInt32 in module faiss.swigfaiss

class MaybeOwnedVectorInt32(builtins.object)
 |  MaybeOwnedVectorInt32(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, *args)
 |
 |  begin(self, *args)
 |
 |  byte_size(self)
 |
 |  clear(self)
 |
 |  data(self, *args)
 |
 |  end(self, *args)
 |
 |  erase(self, begin, end)
 |
 |  resize(self, *args)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorInt32(...)
 |
 |  create_view(address, n_elements, owner)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  c_ptr
 |
 |  c_size
 |
 |  is_owned
 |
 |  owned_data
 |
 |  owner
 |
 |  thisown
 |      The membership flag
 |
 |  view_data
 |
 |  view_size

Python Library Documentation: class MaybeOwnedVectorInt32Vector in module faiss.swigfaiss

class MaybeOwnedVectorInt32Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorInt32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class MaybeOwnedVectorOwner in module faiss.swigfaiss

class MaybeOwnedVectorOwner(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorOwner(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class MaybeOwnedVectorUInt8 in module faiss.swigfaiss

class MaybeOwnedVectorUInt8(builtins.object)
 |  MaybeOwnedVectorUInt8(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, *args)
 |
 |  begin(self, *args)
 |
 |  byte_size(self)
 |
 |  clear(self)
 |
 |  data(self, *args)
 |
 |  end(self, *args)
 |
 |  erase(self, begin, end)
 |
 |  resize(self, *args)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorUInt8(...)
 |
 |  create_view(address, n_elements, owner)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  c_ptr
 |
 |  c_size
 |
 |  is_owned
 |
 |  owned_data
 |
 |  owner
 |
 |  thisown
 |      The membership flag
 |
 |  view_data
 |
 |  view_size

Python Library Documentation: class MaybeOwnedVectorUInt8Vector in module faiss.swigfaiss

class MaybeOwnedVectorUInt8Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MaybeOwnedVectorUInt8Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class MmappedFileMappingOwner in module faiss.swigfaiss

class MmappedFileMappingOwner(MaybeOwnedVectorOwner)
 |  MmappedFileMappingOwner(*args)
 |
 |  Method resolution order:
 |      MmappedFileMappingOwner
 |      MaybeOwnedVectorOwner
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  data(self)
 |
 |  size(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MmappedFileMappingOwner(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MaybeOwnedVectorOwner:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class MultiIndexQuantizer in module faiss.swigfaiss

class MultiIndexQuantizer(Index)
 |  MultiIndexQuantizer(*args)
 |
 |  Quantizer where centroids are virtual: they are the Cartesian
 |  product of sub-centroids.
 |
 |  Method resolution order:
 |      MultiIndexQuantizer
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       number of bit per subvector index
 |      :type d: int
 |      :param d: dimension of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      add and reset will crash at runtime
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MultiIndexQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  pq
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class MultiIndexQuantizer2 in module faiss.swigfaiss

class MultiIndexQuantizer2(MultiIndexQuantizer)
 |  MultiIndexQuantizer2(*args)
 |
 |  MultiIndexQuantizer where the PQ assignment is performed by sub-indexes
 |
 |  Method resolution order:
 |      MultiIndexQuantizer2
 |      MultiIndexQuantizer
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       number of bit per subvector index
 |      :type d: int
 |      :param d: dimension of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_MultiIndexQuantizer2(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  assign_indexes
 |      M Indexes on d / M dimensions
 |
 |  own_fields
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from MultiIndexQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      add and reset will crash at runtime
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reset(self)
 |      removes all elements from the database.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MultiIndexQuantizer:
 |
 |  pq
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class NNDescent in module faiss.swigfaiss

class NNDescent(builtins.object)
 |  NNDescent(d, K)
 |
 |  Methods defined here:
 |
 |  __init__(self, d, K)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  build(self, qdis, n, verbose)
 |
 |  eval_recall(self, ctrl_points, acc_eval_set)
 |      Evaluate the quality of KNNG built
 |
 |  generate_eval_set(self, qdis, c, v, N)
 |      Sample a small number of points to evaluate the quality of KNNG built
 |
 |  init_graph(self, qdis)
 |      Initialize the KNN graph randomly
 |
 |  join(self, qdis)
 |      Perform local join on each node
 |
 |  nndescent(self, qdis, verbose)
 |      Perform NNDescent algorithm
 |
 |  reset(self)
 |
 |  search(self, qdis, topk, indices, dists, vt)
 |
 |  update(self)
 |      Sample new neighbors for each node to perform local join later
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_NNDescent(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  K
 |
 |  L
 |
 |  R
 |
 |  S
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |
 |  final_graph
 |
 |  graph
 |
 |  has_built
 |
 |  iter
 |
 |  ntotal
 |
 |  random_seed
 |
 |  search_L
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class NSG in module faiss.swigfaiss

class NSG(builtins.object)
 |  NSG(R=32)
 |
 |  Methods defined here:
 |
 |  __init__(self, R=32)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_reverse_links(self, q, locks, dis, graph)
 |
 |  attach_unlinked(self, storage, vt, vt2, degrees)
 |
 |  build(self, storage, n, knn_graph, verbose)
 |
 |  check_graph(self)
 |
 |  dfs(self, vt, root, cnt)
 |
 |  get_final_graph(self)
 |
 |  init_graph(self, storage, knn_graph)
 |
 |  link(self, storage, knn_graph, graph, verbose)
 |
 |  reset(self)
 |
 |  search(self, dis, k, I, D, vt)
 |
 |  sync_prune(self, q, pool, dis, vt, knn_graph, graph)
 |
 |  tree_grow(self, storage, degrees)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_NSG(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  C
 |      candidate pool size at construction time
 |
 |  L
 |      length of the search path at construction time
 |
 |  R
 |      nb of neighbors per node
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  enterpoint
 |      enterpoint
 |
 |  final_graph
 |      NSG graph structure
 |
 |  is_built
 |      NSG is built or not
 |
 |  ntotal
 |      nb of nodes
 |
 |  rng
 |      random generator
 |
 |  search_L
 |      length of the search path
 |
 |  thisown
 |      The membership flag
 |
 |  use_visited_hashset

Python Library Documentation: class NSG_Graph_int in module faiss.swigfaiss

class NSG_Graph_int(builtins.object)
 |  NSG_Graph_int(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, *args)
 |
 |  get_neighbors(self, i, neighbors)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_NSG_Graph_int(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  K
 |      nb of neighbors per node
 |
 |  N
 |      total nb of nodes
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  data
 |      the flattened adjacency matrix, size N-by-K
 |
 |  own_fields
 |      the underlying data owned by itself or not
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class NegativeDistanceComputer in module faiss.swigfaiss

class NegativeDistanceComputer(DistanceComputer)
 |  NegativeDistanceComputer(basedis_)
 |
 |  Method resolution order:
 |      NegativeDistanceComputer
 |      DistanceComputer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, i)
 |      compute distance of vector i to current query
 |
 |  __init__(self, basedis_)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
 |      compute distances of current query to 4 stored vectors.
 |      certain DistanceComputer implementations may benefit
 |      heavily from this.
 |
 |  set_query(self, x)
 |      called before computing distances. Pointer x should remain valid
 |      while operator () is called
 |
 |  symmetric_dis(self, i, j)
 |      compute distance between two stored vectors
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_NegativeDistanceComputer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  basedis
 |      owned by this
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from DistanceComputer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class Neighbor in module faiss.swigfaiss

class Neighbor(builtins.object)
 |  Neighbor(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Neighbor(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  distance
 |
 |  flag
 |
 |  id
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class NeuralNetCodec in module faiss.swigfaiss

class NeuralNetCodec(builtins.object)
 |  NeuralNetCodec(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, codes)
 |
 |  encode(self, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_NeuralNetCodec(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Nhood in module faiss.swigfaiss

class Nhood(builtins.object)
 |  Nhood(*args)
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  insert(self, id, dist)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Nhood(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  nn_new
 |
 |  nn_old
 |
 |  pool
 |
 |  rnn_new
 |
 |  rnn_old
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class NormalizationTransform in module faiss.swigfaiss

class NormalizationTransform(VectorTransform)
 |  NormalizationTransform(*args)
 |
 |  per-vector normalization
 |
 |  Method resolution order:
 |      NormalizationTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |       apply the transformation and return the result in a provided matrix
 |      :type n: int
 |      :param n: number of vectors to transform
 |      :type x: float
 |      :param x: input vectors, size n * d_in
 |      :type xt: float
 |      :param xt: output vectors, size n * d_out
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      Identity transform since norm is not revertible
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x) from faiss.swigfaiss.VectorTransform
 |       Perform training on a representative set of vectors. Does
 |      nothing by default.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_NormalizationTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  norm
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class OPQMatrix in module faiss.swigfaiss

class OPQMatrix(LinearTransform)
 |  OPQMatrix(d=0, M_in=1, d2=-1)
 |
 |   Applies a rotation to align the dimensions with a PQ to minimize
 |   the reconstruction error. Can be used before an IndexPQ or an
 |   IndexIVFPQ. The method is the non-parametric version described in:
 |
 |  "Optimized Product Quantization for Approximate Nearest Neighbor Search"
 |  Tiezheng Ge, Kaiming He, Qifa Ke, Jian Sun, CVPR'13
 |
 |  Method resolution order:
 |      OPQMatrix
 |      LinearTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, d=0, M_in=1, d2=-1)
 |      if d2 != -1, output vectors of this dimension
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_OPQMatrix(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |      nb of subquantizers
 |
 |  max_train_points
 |      if there are too many training points, resample
 |
 |  niter
 |      Number of outer training iterations
 |
 |  niter_pq
 |      Number of training iterations for the PQ
 |
 |  niter_pq_0
 |      same, for the first outer iteration
 |
 |  pq
 |      if non-NULL, use this product quantizer for training
 |      should be constructed with (d_out, M, _)
 |
 |  thisown
 |      The membership flag
 |
 |  verbose
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from LinearTransform:
 |
 |  apply_noalloc(self, n, x, xt)
 |      same as apply, but result is pre-allocated
 |
 |  check_identical(self, other)
 |
 |  print_if_verbose(self, name, mat, n, d)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      works only if is_orthonormal
 |
 |  set_is_orthonormal(self)
 |      compute A^T * A to set the is_orthonormal flag
 |
 |  transform_transpose(self, n, y, x)
 |      compute x = A^T * (x - b)
 |      is reverse transform if A has orthonormal lines
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from LinearTransform:
 |
 |  A
 |      Transformation matrix, size d_out * d_in
 |
 |  b
 |      bias vector, size d_out
 |
 |  have_bias
 |
 |  is_orthonormal
 |      whether to use the bias term
 |       check if matrix A is orthonormal (enables reverse_transform)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class OneRecallAtRCriterion in module faiss.swigfaiss

class OneRecallAtRCriterion(AutoTuneCriterion)
 |  OneRecallAtRCriterion(nq, R)
 |
 |  Method resolution order:
 |      OneRecallAtRCriterion
 |      AutoTuneCriterion
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, nq, R)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  evaluate(self, D, I)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_OneRecallAtRCriterion(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  R
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AutoTuneCriterion:
 |
 |  evaluate_c = evaluate(self, D, I)
 |       Evaluate the criterion.
 |
 |      :type D: float
 |      :param D:  size nq * nnn
 |      :type I: int
 |      :param I:  size nq * nnn
 |      :rtype: float
 |      :return: the criterion, between 0 and 1. Larger is better.
 |
 |  set_groundtruth = replacement_set_groundtruth(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
 |
 |  set_groundtruth_c = set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
 |       Initializes the gt_D and gt_I vectors. Must be called before evaluating
 |
 |      :type gt_D_in: float
 |      :param gt_D_in:  size nq * gt_nnn
 |      :type gt_I_in: int
 |      :param gt_I_in:  size nq * gt_nnn
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AutoTuneCriterion:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  gt_D
 |      Ground-truth distances (size nq * gt_nnn)
 |
 |  gt_I
 |      Ground-truth indexes (size nq * gt_nnn)
 |
 |  gt_nnn
 |      nb of GT NNs required to evaluate criterion
 |
 |  nnn
 |      nb of NNs that the query should request
 |
 |  nq
 |      nb of queries this criterion is evaluated on

Python Library Documentation: class OperatingPoint in module faiss.swigfaiss

class OperatingPoint(builtins.object)
 |  Maintains a list of experimental results. Each operating point is a
 |  (perf, t, key) triplet, where higher perf and lower t is
 |  better. The key field is an arbitrary identifier for the operating point.
 |
 |  Includes primitives to extract the Pareto-optimal operating points in the
 |  (perf, t) space.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_OperatingPoint(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  cno
 |      integer identifier
 |
 |  key
 |      key that identifies this op pt
 |
 |  perf
 |      performance measure (output of a Criterion)
 |
 |  t
 |      corresponding execution time (ms)
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class OperatingPointVector in module faiss.swigfaiss

class OperatingPointVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_OperatingPointVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class OperatingPoints in module faiss.swigfaiss

class OperatingPoints(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, perf, t, key, cno=0)
 |      add a performance measure. Return whether it is an optimal point
 |
 |  all_to_gnuplot(self, fname)
 |      output to a format easy to digest by gnuplot
 |
 |  clear(self)
 |
 |  display(self, only_optimal=True)
 |      easy-to-read output
 |
 |  merge_with(self, *args)
 |      add operating points from other to this, with a prefix to the keys
 |
 |  optimal_to_gnuplot(self, fname)
 |
 |  t_for_perf(self, perf)
 |      get time required to obtain a given performance measure
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_OperatingPoints(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  all_pts
 |      all operating points
 |
 |  optimal_pts
 |      optimal operating points, sorted by perf
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PCAMatrix in module faiss.swigfaiss

class PCAMatrix(LinearTransform)
 |  PCAMatrix(din=0, dout=0, eigen_power_in=0, random_rotation_in=False)
 |
 |  Applies a principal component analysis on a set of vectors,
 |  with optionally whitening and random rotation.
 |
 |  Method resolution order:
 |      PCAMatrix
 |      LinearTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, din=0, dout=0, eigen_power_in=0, random_rotation_in=False)
 |      both d_in > d_out and d_out < d_in are supported
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  copy_from(self, other)
 |      copy pre-trained PCA matrix
 |
 |  prepare_Ab(self)
 |      called after mean, PCAMat and eigenvalues are computed
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |      train on n vectors. If n < d_in then the eigenvector matrix
 |      will be completed with 0s
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PCAMatrix(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  PCAMat
 |      PCA matrix, size d_in * d_in
 |
 |  balanced_bins
 |      try to distribute output eigenvectors in this many bins
 |
 |  eigen_power
 |       after transformation the components are multiplied by
 |      eigenvalues^eigen_power
 |
 |      =0: no whitening
 |      =-0.5: full whitening
 |
 |  eigenvalues
 |      eigenvalues of covariance matrix (= squared singular values)
 |
 |  epsilon
 |      value added to eigenvalues to avoid division by 0 when whitening
 |
 |  max_points_per_d
 |      ratio between # training vectors and dimension
 |
 |  mean
 |      Mean, size d_in
 |
 |  random_rotation
 |      random rotation after PCA
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from LinearTransform:
 |
 |  apply_noalloc(self, n, x, xt)
 |      same as apply, but result is pre-allocated
 |
 |  check_identical(self, other)
 |
 |  print_if_verbose(self, name, mat, n, d)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      works only if is_orthonormal
 |
 |  set_is_orthonormal(self)
 |      compute A^T * A to set the is_orthonormal flag
 |
 |  transform_transpose(self, n, y, x)
 |      compute x = A^T * (x - b)
 |      is reverse transform if A has orthonormal lines
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from LinearTransform:
 |
 |  A
 |      Transformation matrix, size d_out * d_in
 |
 |  b
 |      bias vector, size d_out
 |
 |  have_bias
 |
 |  is_orthonormal
 |      whether to use the bias term
 |       check if matrix A is orthonormal (enables reverse_transform)
 |
 |  verbose
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class PQDecoder16 in module faiss.swigfaiss

class PQDecoder16(builtins.object)
 |  PQDecoder16(code, nbits)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, nbits)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PQDecoder16(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  nbits = 16

Python Library Documentation: class PQDecoder8 in module faiss.swigfaiss

class PQDecoder8(builtins.object)
 |  PQDecoder8(code, nbits)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, nbits)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PQDecoder8(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  nbits = 8

Python Library Documentation: class PQDecoderGeneric in module faiss.swigfaiss

class PQDecoderGeneric(builtins.object)
 |  PQDecoderGeneric(code, nbits)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, nbits)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PQDecoderGeneric(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  mask
 |
 |  nbits
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  offset
 |
 |  reg
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PQEncoder16 in module faiss.swigfaiss

class PQEncoder16(builtins.object)
 |  PQEncoder16(code, nbits)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, nbits)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  encode(self, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PQEncoder16(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PQEncoder8 in module faiss.swigfaiss

class PQEncoder8(builtins.object)
 |  PQEncoder8(code, nbits)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, nbits)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  encode(self, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PQEncoder8(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PQEncoderGeneric in module faiss.swigfaiss

class PQEncoderGeneric(builtins.object)
 |  PQEncoderGeneric(code, nbits, offset=0)
 |
 |  Methods defined here:
 |
 |  __init__(self, code, nbits, offset=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  encode(self, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PQEncoderGeneric(...)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  nbits
 |      number of bits per subquantizer index
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code
 |      code for this vector
 |
 |  offset
 |
 |  reg
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Panorama in module faiss.swigfaiss

class Panorama(builtins.object)
 |  Panorama(code_size, n_levels, batch_size)
 |
 |  Implements the core logic of Panorama-based refinement.
 |  arXiv: https://arxiv.org/abs/2510.00566
 |
 |  Panorama partitions the dimensions of all vectors into L contiguous levels.
 |  During the refinement stage of ANNS, it computes distances between the query
 |  and its candidates level-by-level. After processing each level, it prunes the
 |  candidates whose lower bound exceeds the k-th best distance.
 |
 |  In order to enable speedups, the dimensions (or codes) of each vector are
 |  stored in a batched, level-major manner. Within each batch of b vectors, the
 |  dimensions corresponding to level 1 will be stored first (for all elements in
 |  that batch), followed by level 2, and so on. This allows for efficient memory
 |  access patterns.
 |
 |  Coupled with the appropriate orthogonal PreTransform (e.g. PCA, Cayley,
 |  etc.), Panorama can prune the vast majority of dimensions, greatly
 |  accelerating the refinement stage.
 |
 |  Methods defined here:
 |
 |  __init__(self, code_size, n_levels, batch_size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_cumulative_sums(self, cumsum_base, offset, n_entry, vectors)
 |      Helper method to compute the cumulative sums of the codes.
 |      The cumsums also follow the level-oriented batch layout to minimize the
 |      number of random memory accesses.
 |
 |  compute_query_cum_sums(self, query, query_cum_sums)
 |      Compute the cumulative sums of the query vector.
 |
 |  copy_codes_to_level_layout(self, codes, offset, n_entry, code)
 |      Helper method to copy codes into level-oriented batch layout at a given
 |      offset in the list.
 |
 |  copy_entry(self, dest_codes, src_codes, dest_cum_sums, src_cum_sums, dest_idx, src_idx)
 |      Copy single entry (code and cum_sum) from one location to another.
 |
 |  reconstruct(self, key, recons, codes_base)
 |      Panorama's core progressive filtering algorithm:
 |      Process vectors in batches for cache efficiency. For each batch:
 |      1. Apply ID selection filter and initialize distances
 |      (||y||^2 + ||x||^2).
 |      2. Maintain an "active set" of candidate indices that haven't been
 |      pruned yet.
 |      3. For each level, refine distances incrementally and compact the active
 |      set:
 |         - Compute dot product for current level: exact_dist -= 2*<x,y>.
 |         - Use Cauchy-Schwarz bound on remaining levels to get lower bound
 |         - Prune candidates whose lower bound exceeds k-th best distance.
 |         - Compact active_indices to remove pruned candidates (branchless)
 |      4. After all levels, survivors are exact distances; update heap.
 |      This achieves early termination while maintaining SIMD-friendly
 |      sequential access patterns in the level-oriented storage layout.
 |
 |  set_derived_values(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Panorama(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  batch_size
 |
 |  code_size
 |
 |  d
 |
 |  level_width
 |
 |  level_width_floats
 |
 |  n_levels
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  kDefaultBatchSize = 128

Python Library Documentation: class PanoramaStats in module faiss.swigfaiss

class PanoramaStats(builtins.object)
 |  Statistics are not robust to internal threading nor to
 |  concurrent Panorama searches. Use these values in a
 |  single-threaded context to accurately gauge Panorama's
 |  pruning effectiveness.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, other)
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PanoramaStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ratio_dims_scanned
 |
 |  thisown
 |      The membership flag
 |
 |  total_dims
 |
 |  total_dims_scanned

Python Library Documentation: class ParameterRange in module faiss.swigfaiss

class ParameterRange(builtins.object)
 |  possible values of a parameter, sorted from least to most expensive/accurate
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ParameterRange(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name
 |
 |  thisown
 |      The membership flag
 |
 |  values

Python Library Documentation: class ParameterRangeVector in module faiss.swigfaiss

class ParameterRangeVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ParameterRangeVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ParameterSpace in module faiss.swigfaiss

class ParameterSpace(builtins.object)
 |  Uses a-priori knowledge on the Faiss indexes to extract tunable parameters.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_range(self, name)
 |      add a new parameter (or return it if it exists)
 |
 |  combination_ge(self, c1, c2)
 |      returns whether combinations c1 >= c2 in the tuple sense
 |
 |  combination_name(self, cno)
 |      get string representation of the combination
 |
 |  display(self)
 |      print a description on stdout
 |
 |  explore = replacement_explore(self, index, xq, crit) from faiss.class_wrappers.handle_ParameterSpace.<locals>
 |
 |  explore_c = explore(self, index, nq, xq, crit, ops)
 |       explore operating points
 |      :type index: :py:class:`Index`
 |      :param index:   index to run on
 |      :type xq: float
 |      :param xq:      query vectors (size nq * index.d)
 |      :type crit: :py:class:`AutoTuneCriterion`
 |      :param crit:    selection criterion
 |      :type ops: :py:class:`OperatingPoints`
 |      :param ops:     resulting operating points
 |
 |  initialize(self, index)
 |      initialize with reasonable parameters for the index
 |
 |  n_combinations(self)
 |      nb of combinations, = product of values sizes
 |
 |  set_index_parameter(self, *args)
 |      *Overload 1:*
 |      set one of the parameters
 |
 |      |
 |
 |      *Overload 2:*
 |      set one of the parameters on a binary index
 |
 |  set_index_parameters(self, *args)
 |      *Overload 1:*
 |      set a combination of parameters on an index
 |
 |      |
 |
 |      *Overload 2:*
 |      set a combination of parameters described by a string
 |
 |      |
 |
 |      *Overload 3:*
 |      set a combination of parameters on a binary index
 |
 |      |
 |
 |      *Overload 4:*
 |      set a combination of parameters described by a string on a binary index
 |
 |  update_bounds(self, cno, op, upper_bound_perf, lower_bound_t)
 |       find an upper bound on the performance and a lower bound on t
 |      for configuration cno given another operating point op
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ParameterSpace(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  batchsize
 |      maximum number of queries to submit at a time.
 |
 |  min_test_duration
 |      run tests several times until they reach at least this
 |      duration (to avoid jittering in MT mode)
 |
 |  n_experiments
 |      nb of experiments during optimization (0 = try all combinations)
 |
 |  parameter_ranges
 |      all tunable parameters
 |
 |  thisown
 |      The membership flag
 |
 |  thread_over_batches
 |      use multithreading over batches (useful to benchmark
 |      independent single-searches)
 |
 |  verbose
 |      verbosity during exploration

Python Library Documentation: class PartitionStats in module faiss.swigfaiss

class PartitionStats(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PartitionStats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  bisect_cycles
 |
 |  compress_cycles
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PermutationObjective in module faiss.swigfaiss

class PermutationObjective(builtins.object)
 |  PermutationObjective(*args, **kwargs)
 |
 |  abstract class for the loss function
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_cost(self, perm)
 |
 |  cost_update(self, perm, iw, jw)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PermutationObjective(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PolysemousTraining in module faiss.swigfaiss

class PolysemousTraining(SimulatedAnnealingParameters)
 |  optimizes the order of indices in a ProductQuantizer
 |
 |  Method resolution order:
 |      PolysemousTraining
 |      SimulatedAnnealingParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  memory_usage_per_thread(self, pq)
 |      make sure we don't blow up the memory
 |
 |  optimize_pq_for_hamming(self, pq, n, x)
 |      reorder the centroids so that the Hamming distance becomes a
 |      good approximation of the SDC distance (called by train)
 |
 |  optimize_ranking(self, pq, n, x)
 |      called by optimize_pq_for_hamming
 |
 |  optimize_reproduce_distances(self, pq)
 |      called by optimize_pq_for_hamming
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PolysemousTraining(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  dis_weight_factor
 |      decay of exp that weights distance loss
 |
 |  log_pattern
 |
 |  max_memory
 |      refuse to train if it would require more than that amount of RAM
 |
 |  ntrain_permutation
 |       use 1/4 of the training points for the optimization, with
 |      max. ntrain_permutation. If ntrain_permutation == 0: train on
 |      centroids
 |
 |  optimization_type
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  OT_None = 0
 |
 |  OT_Ranking_weighted_diff = 2
 |
 |  OT_ReproduceDistances_affine = 1
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SimulatedAnnealingParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  init_random
 |
 |  init_temperature
 |
 |  n_iter
 |
 |  n_redo
 |
 |  only_bit_flips
 |
 |  seed
 |
 |  temperature_decay
 |
 |  verbose

Python Library Documentation: class ProductAdditiveQuantizer in module faiss.swigfaiss

class ProductAdditiveQuantizer(AdditiveQuantizer)
 |  ProductAdditiveQuantizer(*args)
 |
 |   Product Additive Quantizers
 |
 |  The product additive quantizer is a variant of AQ and PQ.
 |  It first splits the vector space into multiple orthogonal sub-spaces
 |  just like PQ does. And then it quantizes each sub-space by an independent
 |  additive quantizer.
 |
 |  Method resolution order:
 |      ProductAdditiveQuantizer
 |      AdditiveQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |       Construct a product additive quantizer.
 |
 |      The additive quantizers passed in will be cloned into the
 |      ProductAdditiveQuantizer object.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type aqs: std::vector< faiss::AdditiveQuantizer * >
 |      :param aqs:    sub-additive quantizers
 |      :type search_type: int, optional
 |      :param search_type:  AQ search type
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
 |       Compute inner-product look-up tables. Used in the search functions.
 |
 |      :type xq: float
 |      :param xq:     query vector, size (n, d)
 |      :type LUT: float
 |      :param LUT:    look-up table, size (n, total_codebook_size)
 |      :type alpha: float, optional
 |      :param alpha:  compute alpha * inner-product
 |      :type ld_lut: int, optional
 |      :param ld_lut:  leading dimension of LUT
 |
 |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |      :type centroids: float, optional
 |      :param centroids:  centroids to be added to x, size n * d
 |
 |  compute_unpacked_codes(self, x, codes, n, centroids=None)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, codes, x, n)
 |       Decode a set of vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  decode_unpacked(self, codes, x, n, ld_codes=-1)
 |       Decode a set of vectors in non-packed format
 |
 |      :type codes: int
 |      :param codes:  codes to decode, size n * ld_codes
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  init(self, d, aqs, search_type)
 |
 |  subquantizer(self, m)
 |      Train the product additive quantizer
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProductAdditiveQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  nsplits
 |      number of sub-vectors we split a vector into
 |
 |  quantizers
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveQuantizer:
 |
 |  compute_centroid_norms(self, norms)
 |       For L2 search we need the L2 norms of the centroids
 |
 |      :type norms: float
 |      :param norms:    output norms table, size total_codebook_size
 |
 |  compute_codebook_tables(self)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  decode_64bit(self, n, x)
 |      decoding function for a code in a 64-bit word
 |
 |  decode_qcint(self, c)
 |      decode norm by non-uniform scalar quantization
 |
 |  encode_norm(self, norm)
 |      encode a norm into norm_bits bits
 |
 |  encode_qcint(self, x)
 |      encode norm by non-uniform scalar quantization
 |
 |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
 |      Exact L2 search, with precomputed norms
 |
 |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
 |      exact IP search
 |
 |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
 |       pack a series of code to bit-compact format
 |
 |      :type codes: int
 |      :param codes:        codes to be packed, size n * code_size
 |      :type packed_codes: uint8_t
 |      :param packed_codes: output bit-compact codes
 |      :type ld_codes: int, optional
 |      :param ld_codes:     leading dimension of codes
 |      :type norms: float, optional
 |      :param norms:        norms of the vectors (size n). Will be computed if
 |                              needed but not provided
 |      :type centroids: float, optional
 |      :param centroids:    centroids to be added to x, size n * d
 |
 |  set_derived_values(self)
 |      Train the norm quantizer
 |
 |  train_norm(self, n, norms)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveQuantizer:
 |
 |  M
 |      number of codebooks
 |
 |  centroid_norms
 |      norms of all codebook entries (size total_codebook_size)
 |
 |  codebook_cross_products
 |      dot products of all codebook entries with the previous codebooks
 |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
 |
 |  codebook_offsets
 |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
 |      in the codebooks table of size total_codebook_size by d
 |
 |  codebooks
 |      codebooks
 |
 |  is_trained
 |      is trained or not
 |
 |  max_mem_distances
 |      norms and distance matrixes with beam search can get large, so use this
 |      to control for the amount of memory that can be allocated
 |
 |  nbits
 |      bits for each step
 |
 |  norm_bits
 |      bits allocated for the norms
 |
 |  norm_max
 |
 |  norm_min
 |      min/max for quantization of norms
 |
 |  norm_tabs
 |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
 |      store norms of codebook entries for 4-bit fastscan
 |
 |  only_8bit
 |      are all nbits = 8 (use faster decoder)
 |
 |  qnorm
 |      store and search norms
 |
 |  search_type
 |      Also determines what's in the codes
 |
 |  tot_bits
 |      total number of bits (indexes + norms)
 |
 |  total_codebook_size
 |      size of the codebook in vectors
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from AdditiveQuantizer:
 |
 |  ST_LUT_nonorm = 1
 |
 |  ST_count = 10
 |
 |  ST_decompress = 0
 |
 |  ST_norm_cqint4 = 7
 |
 |  ST_norm_cqint8 = 6
 |
 |  ST_norm_float = 3
 |
 |  ST_norm_from_LUT = 2
 |
 |  ST_norm_lsq2x4 = 8
 |
 |  ST_norm_qint4 = 5
 |
 |  ST_norm_qint8 = 4
 |
 |  ST_norm_rq2x4 = 9
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class ProductLocalSearchQuantizer in module faiss.swigfaiss

class ProductLocalSearchQuantizer(ProductAdditiveQuantizer)
 |  ProductLocalSearchQuantizer(*args)
 |
 |  Product Local Search Quantizer
 |
 |  Method resolution order:
 |      ProductLocalSearchQuantizer
 |      ProductAdditiveQuantizer
 |      AdditiveQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |       Construct a product LSQ object.
 |
 |      :type d: int
 |      :param d:   dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of sub-vectors we split a vector into
 |      :type Msub: int
 |      :param Msub:     number of codebooks of each LSQ
 |      :type nbits: int
 |      :param nbits:    bits for each step
 |      :type search_type: int, optional
 |      :param search_type:  AQ search type
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProductLocalSearchQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ProductAdditiveQuantizer:
 |
 |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
 |       Compute inner-product look-up tables. Used in the search functions.
 |
 |      :type xq: float
 |      :param xq:     query vector, size (n, d)
 |      :type LUT: float
 |      :param LUT:    look-up table, size (n, total_codebook_size)
 |      :type alpha: float, optional
 |      :param alpha:  compute alpha * inner-product
 |      :type ld_lut: int, optional
 |      :param ld_lut:  leading dimension of LUT
 |
 |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |      :type centroids: float, optional
 |      :param centroids:  centroids to be added to x, size n * d
 |
 |  compute_unpacked_codes(self, x, codes, n, centroids=None)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, codes, x, n)
 |       Decode a set of vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  decode_unpacked(self, codes, x, n, ld_codes=-1)
 |       Decode a set of vectors in non-packed format
 |
 |      :type codes: int
 |      :param codes:  codes to decode, size n * ld_codes
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  init(self, d, aqs, search_type)
 |
 |  subquantizer(self, m)
 |      Train the product additive quantizer
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ProductAdditiveQuantizer:
 |
 |  nsplits
 |      number of sub-vectors we split a vector into
 |
 |  quantizers
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveQuantizer:
 |
 |  compute_centroid_norms(self, norms)
 |       For L2 search we need the L2 norms of the centroids
 |
 |      :type norms: float
 |      :param norms:    output norms table, size total_codebook_size
 |
 |  compute_codebook_tables(self)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  decode_64bit(self, n, x)
 |      decoding function for a code in a 64-bit word
 |
 |  decode_qcint(self, c)
 |      decode norm by non-uniform scalar quantization
 |
 |  encode_norm(self, norm)
 |      encode a norm into norm_bits bits
 |
 |  encode_qcint(self, x)
 |      encode norm by non-uniform scalar quantization
 |
 |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
 |      Exact L2 search, with precomputed norms
 |
 |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
 |      exact IP search
 |
 |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
 |       pack a series of code to bit-compact format
 |
 |      :type codes: int
 |      :param codes:        codes to be packed, size n * code_size
 |      :type packed_codes: uint8_t
 |      :param packed_codes: output bit-compact codes
 |      :type ld_codes: int, optional
 |      :param ld_codes:     leading dimension of codes
 |      :type norms: float, optional
 |      :param norms:        norms of the vectors (size n). Will be computed if
 |                              needed but not provided
 |      :type centroids: float, optional
 |      :param centroids:    centroids to be added to x, size n * d
 |
 |  set_derived_values(self)
 |      Train the norm quantizer
 |
 |  train_norm(self, n, norms)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveQuantizer:
 |
 |  M
 |      number of codebooks
 |
 |  centroid_norms
 |      norms of all codebook entries (size total_codebook_size)
 |
 |  codebook_cross_products
 |      dot products of all codebook entries with the previous codebooks
 |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
 |
 |  codebook_offsets
 |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
 |      in the codebooks table of size total_codebook_size by d
 |
 |  codebooks
 |      codebooks
 |
 |  is_trained
 |      is trained or not
 |
 |  max_mem_distances
 |      norms and distance matrixes with beam search can get large, so use this
 |      to control for the amount of memory that can be allocated
 |
 |  nbits
 |      bits for each step
 |
 |  norm_bits
 |      bits allocated for the norms
 |
 |  norm_max
 |
 |  norm_min
 |      min/max for quantization of norms
 |
 |  norm_tabs
 |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
 |      store norms of codebook entries for 4-bit fastscan
 |
 |  only_8bit
 |      are all nbits = 8 (use faster decoder)
 |
 |  qnorm
 |      store and search norms
 |
 |  search_type
 |      Also determines what's in the codes
 |
 |  tot_bits
 |      total number of bits (indexes + norms)
 |
 |  total_codebook_size
 |      size of the codebook in vectors
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from AdditiveQuantizer:
 |
 |  ST_LUT_nonorm = 1
 |
 |  ST_count = 10
 |
 |  ST_decompress = 0
 |
 |  ST_norm_cqint4 = 7
 |
 |  ST_norm_cqint8 = 6
 |
 |  ST_norm_float = 3
 |
 |  ST_norm_from_LUT = 2
 |
 |  ST_norm_lsq2x4 = 8
 |
 |  ST_norm_qint4 = 5
 |
 |  ST_norm_qint8 = 4
 |
 |  ST_norm_rq2x4 = 9
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class ProductQuantizer in module faiss.swigfaiss

class ProductQuantizer(Quantizer)
 |  ProductQuantizer(*args)
 |
 |   Product Quantizer.
 |  PQ is trained using k-means, minimizing the L2 distance to centroids.
 |  PQ supports L2 and Inner Product search, however the quantization error is
 |  biased towards L2 distance.
 |
 |  Method resolution order:
 |      ProductQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  clear_transposed_centroids(self)
 |      Clear transposed centroids table so ones are no longer used.
 |
 |  compute_code(self, x, code)
 |      Quantize one vector with the product quantizer
 |
 |  compute_code_from_distance_table(self, tab, code)
 |      If we happen to have the distance tables precomputed, this is
 |      more efficient to compute the codes.
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |      same as compute_code for several vectors
 |
 |  compute_codes_with_assign_index(self, x, codes, n)
 |      speed up code assignment using assign_index
 |      (non-const because the index is changed)
 |
 |  compute_distance_table(self, x, dis_table)
 |       Compute distance table for one vector.
 |
 |      The distance table for x = [x_0 x_1 .. x_(M-1)] is a M * ksub
 |      matrix that contains
 |
 |        dis_table (m, j) = || x_m - c_(m, j)||^2
 |        for m = 0..M-1 and j = 0 .. ksub - 1
 |
 |      where c_(m, j) is the centroid no j of sub-quantizer m.
 |
 |      :type x: float
 |      :param x:         input vector size d
 |      :type dis_table: float
 |      :param dis_table: output table, size M * ksub
 |
 |  compute_distance_tables(self, nx, x, dis_tables)
 |       compute distance table for several vectors
 |      :type nx: int
 |      :param nx:        nb of input vectors
 |      :type x: float
 |      :param x:         input vector size nx * d
 |      :param dis_table: output table, size nx * M * ksub
 |
 |  compute_inner_prod_table(self, x, dis_table)
 |
 |  compute_inner_prod_tables(self, nx, x, dis_tables)
 |
 |  compute_sdc_table(self)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, *args)
 |      decode a vector from a given code (or n vectors if third argument)
 |
 |  get_centroids(self, m, i)
 |      return the centroids associated with subvector m
 |
 |  search(self, x, nx, codes, ncodes, res, init_finalize_heap=True)
 |       perform a search (L2 distance)
 |      :type x: float
 |      :param x:        query vectors, size nx * d
 |      :type nx: int
 |      :param nx:       nb of queries
 |      :type codes: uint8_t
 |      :param codes:    database codes, size ncodes * code_size
 |      :type ncodes: int
 |      :param ncodes:   nb of nb vectors
 |      :type res: :py:class:`float_maxheap_array_t`
 |      :param res:      heap array to store results (nh == nx)
 |      :type init_finalize_heap: boolean, optional
 |      :param init_finalize_heap:  initialize heap (input) and sort (output)?
 |
 |  search_ip(self, x, nx, codes, ncodes, res, init_finalize_heap=True)
 |      same as search, but with inner product similarity
 |
 |  search_sdc(self, qcodes, nq, bcodes, ncodes, res, init_finalize_heap=True)
 |
 |  set_derived_values(self)
 |      compute derived values when d, M and nbits have been set
 |
 |  set_params(self, centroids, m)
 |      Define the centroids for subquantizer m
 |
 |  sync_transposed_centroids(self)
 |      Sync transposed centroids with regular centroids. This call
 |      is needed if centroids were edited directly.
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProductQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  M
 |      number of subquantizers
 |
 |  assign_index
 |      if non-NULL, use this index for assignment (should be of size
 |      d / M)
 |
 |  centroids
 |      Centroid table, size M * ksub * dsub.
 |      Layout: (M, ksub, dsub)
 |
 |  centroids_sq_lengths
 |      Squared lengths of centroids, size M * ksub
 |      Layout: (M, ksub)
 |
 |  cp
 |      parameters used during clustering
 |
 |  dsub
 |      dimensionality of each subvector
 |
 |  ksub
 |      number of centroids for each subquantizer
 |
 |  nbits
 |      number of bits per quantization index
 |
 |  sdc_table
 |      Symmetric Distance Table
 |
 |  thisown
 |      The membership flag
 |
 |  train_type
 |
 |  transposed_centroids
 |      Transposed centroid table, size M * ksub * dsub.
 |      Layout: (dsub, M, ksub)
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  Train_default = 0
 |
 |  Train_hot_start = 1
 |
 |  Train_hypercube = 3
 |
 |  Train_hypercube_pca = 4
 |
 |  Train_shared = 2
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class ProductResidualQuantizer in module faiss.swigfaiss

class ProductResidualQuantizer(ProductAdditiveQuantizer)
 |  ProductResidualQuantizer(*args)
 |
 |  Product Residual Quantizer
 |
 |  Method resolution order:
 |      ProductResidualQuantizer
 |      ProductAdditiveQuantizer
 |      AdditiveQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |       Construct a product RQ object.
 |
 |      :type d: int
 |      :param d:   dimensionality of the input vectors
 |      :type nsplits: int
 |      :param nsplits:  number of sub-vectors we split a vector into
 |      :type Msub: int
 |      :param Msub:     number of codebooks of each RQ
 |      :type nbits: int
 |      :param nbits:    bits for each step
 |      :type search_type: int, optional
 |      :param search_type:  AQ search type
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProductResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ProductAdditiveQuantizer:
 |
 |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
 |       Compute inner-product look-up tables. Used in the search functions.
 |
 |      :type xq: float
 |      :param xq:     query vector, size (n, d)
 |      :type LUT: float
 |      :param LUT:    look-up table, size (n, total_codebook_size)
 |      :type alpha: float, optional
 |      :param alpha:  compute alpha * inner-product
 |      :type ld_lut: int, optional
 |      :param ld_lut:  leading dimension of LUT
 |
 |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |      :type centroids: float, optional
 |      :param centroids:  centroids to be added to x, size n * d
 |
 |  compute_unpacked_codes(self, x, codes, n, centroids=None)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, codes, x, n)
 |       Decode a set of vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  decode_unpacked(self, codes, x, n, ld_codes=-1)
 |       Decode a set of vectors in non-packed format
 |
 |      :type codes: int
 |      :param codes:  codes to decode, size n * ld_codes
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  init(self, d, aqs, search_type)
 |
 |  subquantizer(self, m)
 |      Train the product additive quantizer
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ProductAdditiveQuantizer:
 |
 |  nsplits
 |      number of sub-vectors we split a vector into
 |
 |  quantizers
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveQuantizer:
 |
 |  compute_centroid_norms(self, norms)
 |       For L2 search we need the L2 norms of the centroids
 |
 |      :type norms: float
 |      :param norms:    output norms table, size total_codebook_size
 |
 |  compute_codebook_tables(self)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  decode_64bit(self, n, x)
 |      decoding function for a code in a 64-bit word
 |
 |  decode_qcint(self, c)
 |      decode norm by non-uniform scalar quantization
 |
 |  encode_norm(self, norm)
 |      encode a norm into norm_bits bits
 |
 |  encode_qcint(self, x)
 |      encode norm by non-uniform scalar quantization
 |
 |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
 |      Exact L2 search, with precomputed norms
 |
 |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
 |      exact IP search
 |
 |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
 |       pack a series of code to bit-compact format
 |
 |      :type codes: int
 |      :param codes:        codes to be packed, size n * code_size
 |      :type packed_codes: uint8_t
 |      :param packed_codes: output bit-compact codes
 |      :type ld_codes: int, optional
 |      :param ld_codes:     leading dimension of codes
 |      :type norms: float, optional
 |      :param norms:        norms of the vectors (size n). Will be computed if
 |                              needed but not provided
 |      :type centroids: float, optional
 |      :param centroids:    centroids to be added to x, size n * d
 |
 |  set_derived_values(self)
 |      Train the norm quantizer
 |
 |  train_norm(self, n, norms)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveQuantizer:
 |
 |  M
 |      number of codebooks
 |
 |  centroid_norms
 |      norms of all codebook entries (size total_codebook_size)
 |
 |  codebook_cross_products
 |      dot products of all codebook entries with the previous codebooks
 |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
 |
 |  codebook_offsets
 |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
 |      in the codebooks table of size total_codebook_size by d
 |
 |  codebooks
 |      codebooks
 |
 |  is_trained
 |      is trained or not
 |
 |  max_mem_distances
 |      norms and distance matrixes with beam search can get large, so use this
 |      to control for the amount of memory that can be allocated
 |
 |  nbits
 |      bits for each step
 |
 |  norm_bits
 |      bits allocated for the norms
 |
 |  norm_max
 |
 |  norm_min
 |      min/max for quantization of norms
 |
 |  norm_tabs
 |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
 |      store norms of codebook entries for 4-bit fastscan
 |
 |  only_8bit
 |      are all nbits = 8 (use faster decoder)
 |
 |  qnorm
 |      store and search norms
 |
 |  search_type
 |      Also determines what's in the codes
 |
 |  tot_bits
 |      total number of bits (indexes + norms)
 |
 |  total_codebook_size
 |      size of the codebook in vectors
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from AdditiveQuantizer:
 |
 |  ST_LUT_nonorm = 1
 |
 |  ST_count = 10
 |
 |  ST_decompress = 0
 |
 |  ST_norm_cqint4 = 7
 |
 |  ST_norm_cqint8 = 6
 |
 |  ST_norm_float = 3
 |
 |  ST_norm_from_LUT = 2
 |
 |  ST_norm_lsq2x4 = 8
 |
 |  ST_norm_qint4 = 5
 |
 |  ST_norm_qint8 = 4
 |
 |  ST_norm_rq2x4 = 9
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class ProgressiveDimClustering in module faiss.swigfaiss

class ProgressiveDimClustering(ProgressiveDimClusteringParameters)
 |  ProgressiveDimClustering(*args)
 |
 |   K-means clustering with progressive dimensions used
 |
 |  The clustering first happens in dim 1, then with exponentially increasing
 |  dimension until d (I steps). This is typically applied after a PCA
 |  transformation (optional). Reference:
 |
 |  "Improved Residual Vector Quantization for High-dimensional Approximate
 |  Nearest Neighbor Search"
 |
 |  Shicong Liu, Hongtao Lu, Junru Shao, AAAI'15
 |
 |  https://arxiv.org/abs/1509.05195
 |
 |  Method resolution order:
 |      ProgressiveDimClustering
 |      ProgressiveDimClusteringParameters
 |      ClusteringParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  train(self, n, x, factory)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProgressiveDimClustering(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centroids
 |      centroids (k * d)
 |
 |  d
 |      dimension of the vectors
 |
 |  iteration_stats
 |      stats at every iteration of clustering
 |
 |  k
 |      nb of centroids
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ProgressiveDimClusteringParameters:
 |
 |  apply_pca
 |      apply PCA on input
 |
 |  progressive_dim_steps
 |      number of incremental steps
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ClusteringParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² initialization.
 |      Only used when init_method = AFK_MC2.
 |      Longer chains give better approximation but are slower.
 |
 |  check_input_data_for_NaNs
 |      whether to check for NaNs in an input data
 |
 |  decode_block_size
 |      when the training set is encoded, batch size of the codec decoder
 |
 |  early_stop_threshold
 |      Early stop threshold, the range is [0, 1].
 |      The value of 0 implies a default Faiss behavior,
 |      so the training process stops only if an error
 |      is unchanged from the previous iteration.
 |
 |  frozen_centroids
 |      Use the subset of centroids provided as input and do not change them
 |      during iterations
 |
 |  init_method
 |      Initialization method for centroids.
 |      RANDOM: uniform random sampling (default, current behavior)
 |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
 |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
 |
 |  int_centroids
 |      round centroids coordinates to integer after each iteration?
 |
 |  max_points_per_centroid
 |      to limit size of dataset, otherwise the training set is subsampled
 |
 |  min_points_per_centroid
 |      If fewer than this number of training vectors per centroid are provided,
 |      writes a warning. Note that fewer than 1 point per centroid raises an
 |      exception.
 |
 |  niter
 |      number of clustering iterations
 |
 |  nredo
 |      redo clustering this many times and keep the clusters with the best
 |      objective
 |
 |  seed
 |      seed for the random number generator.
 |      negative values lead to seeding an internal rng with
 |      std::high_resolution_clock.
 |
 |  spherical
 |      whether to normalize centroids after each iteration (useful for inner
 |      product clustering)
 |
 |  update_index
 |      re-train index after each iteration?
 |
 |  use_faster_subsampling
 |      Whether to use splitmix64-based random number generator for subsampling,
 |      which is faster, but may pick duplicate points.
 |
 |  verbose

Python Library Documentation: class ProgressiveDimClusteringParameters in module faiss.swigfaiss

class ProgressiveDimClusteringParameters(ClusteringParameters)
 |  Method resolution order:
 |      ProgressiveDimClusteringParameters
 |      ClusteringParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProgressiveDimClusteringParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  apply_pca
 |      apply PCA on input
 |
 |  progressive_dim_steps
 |      number of incremental steps
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ClusteringParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² initialization.
 |      Only used when init_method = AFK_MC2.
 |      Longer chains give better approximation but are slower.
 |
 |  check_input_data_for_NaNs
 |      whether to check for NaNs in an input data
 |
 |  decode_block_size
 |      when the training set is encoded, batch size of the codec decoder
 |
 |  early_stop_threshold
 |      Early stop threshold, the range is [0, 1].
 |      The value of 0 implies a default Faiss behavior,
 |      so the training process stops only if an error
 |      is unchanged from the previous iteration.
 |
 |  frozen_centroids
 |      Use the subset of centroids provided as input and do not change them
 |      during iterations
 |
 |  init_method
 |      Initialization method for centroids.
 |      RANDOM: uniform random sampling (default, current behavior)
 |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
 |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
 |
 |  int_centroids
 |      round centroids coordinates to integer after each iteration?
 |
 |  max_points_per_centroid
 |      to limit size of dataset, otherwise the training set is subsampled
 |
 |  min_points_per_centroid
 |      If fewer than this number of training vectors per centroid are provided,
 |      writes a warning. Note that fewer than 1 point per centroid raises an
 |      exception.
 |
 |  niter
 |      number of clustering iterations
 |
 |  nredo
 |      redo clustering this many times and keep the clusters with the best
 |      objective
 |
 |  seed
 |      seed for the random number generator.
 |      negative values lead to seeding an internal rng with
 |      std::high_resolution_clock.
 |
 |  spherical
 |      whether to normalize centroids after each iteration (useful for inner
 |      product clustering)
 |
 |  update_index
 |      re-train index after each iteration?
 |
 |  use_faster_subsampling
 |      Whether to use splitmix64-based random number generator for subsampling,
 |      which is faster, but may pick duplicate points.
 |
 |  verbose

Python Library Documentation: class ProgressiveDimIndexFactory in module faiss.swigfaiss

class ProgressiveDimIndexFactory(builtins.object)
 |  generates an index suitable for clustering when called
 |
 |  Methods defined here:
 |
 |  __call__(self, dim)
 |      ownership transferred to caller
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ProgressiveDimIndexFactory(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class PyCallbackIDSelector in module faiss.swigfaiss

class PyCallbackIDSelector(IDSelector)
 |  PyCallbackIDSelector(callback)
 |
 |  Method resolution order:
 |      PyCallbackIDSelector
 |      IDSelector
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, callback)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  is_member(self, id)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PyCallbackIDSelector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  callback
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IDSelector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class PyCallbackIOReader in module faiss.swigfaiss

class PyCallbackIOReader(IOReader)
 |  PyCallbackIOReader(*args)
 |
 |  Method resolution order:
 |      PyCallbackIOReader
 |      IOReader
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptrv, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, *args)
 |       Callback: Python function that takes a size and returns a
 |      bytes object with the resulting read
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PyCallbackIOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  bs
 |
 |  callback
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOReader:
 |
 |  filedescriptor(self)
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOReader:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class PyCallbackIOWriter in module faiss.swigfaiss

class PyCallbackIOWriter(IOWriter)
 |  PyCallbackIOWriter(*args)
 |
 |  Method resolution order:
 |      PyCallbackIOWriter
 |      IOWriter
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptrv, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, *args)
 |      Callback: Python function that takes a bytes object and
 |      returns the number of bytes successfully written.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PyCallbackIOWriter(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  bs
 |
 |  callback
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOWriter:
 |
 |  filedescriptor(self)
 |
 |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOWriter:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class PyCallbackShardingFunction in module faiss.swigfaiss

class PyCallbackShardingFunction(ShardingFunction)
 |  PyCallbackShardingFunction(*args)
 |
 |  Method resolution order:
 |      PyCallbackShardingFunction
 |      ShardingFunction
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, i, shard_count)
 |      Call self as a function.
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PyCallbackShardingFunction(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  callback
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ShardingFunction:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class PythonInterruptCallback in module faiss.swigfaiss

class PythonInterruptCallback(InterruptCallback)
 |  Method resolution order:
 |      PythonInterruptCallback
 |      InterruptCallback
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  want_interrupt(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_PythonInterruptCallback(...)
 |
 |  reset()
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from InterruptCallback:
 |
 |  check()
 |       check if:
 |      - an interrupt callback is set
 |      - the callback returns true
 |      if this is the case, then throw an exception. Should not be called
 |      from multiple threads.
 |
 |  clear_instance()
 |
 |  get_period_hint(flops)
 |       assuming each iteration takes a certain number of flops, what
 |      is a reasonable interval to check for interrupts?
 |
 |  is_interrupted()
 |      same as check() but return true if is interrupted instead of
 |      throwing. Can be called from multiple threads.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InterruptCallback:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class QINCo in module faiss.swigfaiss

class QINCo(NeuralNetCodec)
 |  QINCo(*args)
 |
 |  Method resolution order:
 |      QINCo
 |      NeuralNetCodec
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_QINCo.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, codes)
 |
 |  encode(self, x)
 |
 |  from_torch(self, qinco) from faiss.class_wrappers.handle_QINCo.<locals>
 |      copy weights from torch.QINCo
 |
 |  get_step(self, i)
 |
 |  original_init = __init__(self, d, K, L, M, h)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_QINCo(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  K
 |
 |  L
 |
 |  codebook0
 |
 |  h
 |
 |  steps
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NeuralNetCodec:
 |
 |  M
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d

Python Library Documentation: class QINCoStep in module faiss.swigfaiss

class QINCoStep(builtins.object)
 |  QINCoStep(*args)
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_QINCoStep.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, xhat, codes)
 |
 |  encode(self, xhat, x, residuals=None)
 |       encode a set of vectors x with initial estimate xhat. Optionally return
 |      the delta to be added to xhat to form the new xhat
 |
 |  from_torch(self, step) from faiss.class_wrappers.handle_QINCoStep.<locals>
 |      copy weights from torch.QINCoStep
 |
 |  get_residual_block(self, i)
 |
 |  original_init = __init__(self, d, K, L, h)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_QINCoStep(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  K
 |
 |  L
 |
 |  MLPconcat
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  codebook
 |
 |  d
 |      d: input dim, K: codebook size, L: # of residual blocks, h: hidden dim
 |
 |  h
 |
 |  residual_blocks
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Quantizer in module faiss.swigfaiss

class Quantizer(builtins.object)
 |  Quantizer(*args, **kwargs)
 |
 |  General interface for quantizer objects
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |       Quantize a set of vectors
 |
 |      :type x: float
 |      :param x:        input vectors, size n * d
 |      :type codes: uint8_t
 |      :param codes:    output codes, size n * code_size
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, code, x, n)
 |       Decode a set of vectors
 |
 |      :param codes:    input codes, size n * code_size
 |      :type x: float
 |      :param x:        output vectors, size n * d
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Train the quantizer
 |
 |      :type x: float
 |      :param x:       training vectors, size n * d
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Quantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class QueryFactorsData in module faiss.swigfaiss

class QueryFactorsData(builtins.object)
 |   Query-specific factors computed during search for RaBitQ distance
 |  computation. Used by both IndexRaBitQ and IndexRaBitQFastScan
 |  implementations.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_QueryFactorsData(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  c1
 |
 |  c2
 |
 |  c34
 |
 |  g_error
 |
 |  int_dot_scale
 |
 |  q_dot_c
 |
 |  qr_norm_L2sqr
 |
 |  qr_to_c_L2sqr
 |
 |  rotated_q
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class RaBitQDistanceComputer in module faiss.swigfaiss

class RaBitQDistanceComputer(FlatCodesDistanceComputer)
 |  RaBitQDistanceComputer(*args, **kwargs)
 |
 |  Method resolution order:
 |      RaBitQDistanceComputer
 |      FlatCodesDistanceComputer
 |      DistanceComputer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  distance_to_code(self, code)
 |      compute distance of current query to an encoded vector
 |
 |  distance_to_code_1bit(self, code)
 |
 |  distance_to_code_full(self, code)
 |
 |  symmetric_dis(self, arg2, arg3)
 |      compute distance between two stored vectors
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RaBitQDistanceComputer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centroid
 |
 |  d
 |
 |  g_error
 |
 |  metric_type
 |
 |  nb_bits
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from FlatCodesDistanceComputer:
 |
 |  __call__(self, i)
 |      compute distance of vector i to current query
 |
 |  partial_dot_product(self, arg2, arg3, arg4)
 |      Computes a partial dot product over a slice of the query vector.
 |      The slice is defined by the following parameters:
 |        — `offset`: the starting index of the first component to include
 |        — `num_components`: the number of consecutive components to include
 |
 |      Components refer to raw dimensions of the flat (uncompressed) query
 |      vector.
 |
 |      By default, this method throws an error, as it is only implemented
 |      in specific subclasses such as `FlatL2Dis`. Other flat distance
 |      computers may override this when partial dot product support is needed.
 |
 |      Over time, this method might be changed to a pure virtual function (`=
 |      0`) to enforce implementation in subclasses that require this
 |      functionality.
 |
 |      This method is not part of the generic `DistanceComputer` interface
 |      because for compressed representations (e.g., product quantization),
 |      calling `partial_dot_product` repeatedly is often less efficient than
 |      computing the full distance at once.
 |
 |      Supporting efficient partial scans generally requires a different memory
 |      layout, such as interleaved blocks that keep SIMD lanes full. This is a
 |      non-trivial change and not supported in the current flat layout.
 |
 |      For more details on partial (or chunked) dot product computations and
 |      the performance trade-offs involved, refer to the Panorama paper:
 |      https://arxiv.org/pdf/2510.00566
 |
 |  partial_dot_product_batch_4(self, idx0, idx1, idx2, idx3, dp0, dp1, dp2, dp3, offset, num_components)
 |      Compute partial dot products of current query to 4 stored vectors.
 |      See `partial_dot_product` for more details.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from FlatCodesDistanceComputer:
 |
 |  code_size
 |
 |  codes
 |
 |  q
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from DistanceComputer:
 |
 |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
 |      compute distances of current query to 4 stored vectors.
 |      certain DistanceComputer implementations may benefit
 |      heavily from this.
 |
 |  set_query(self, x)
 |      called before computing distances. Pointer x should remain valid
 |      while operator () is called
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from DistanceComputer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class RaBitQSearchParameters in module faiss.swigfaiss

class RaBitQSearchParameters(SearchParameters)
 |  RaBitQSearchParameters(**args)
 |
 |  Method resolution order:
 |      RaBitQSearchParameters
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RaBitQSearchParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centered
 |
 |  qb
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class RaBitQuantizer in module faiss.swigfaiss

class RaBitQuantizer(Quantizer)
 |  RaBitQuantizer(*args)
 |
 |  Method resolution order:
 |      RaBitQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_code_size(self, d, num_bits)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  compute_codes_core(self, x, codes, n, centroid_in)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, codes, x, n)
 |
 |  decode_core(self, codes, x, n, centroid_in)
 |
 |  get_distance_computer(self, qb=0, centroid=None, centered=False)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RaBitQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  centroid
 |
 |  metric_type
 |
 |  nb_bits
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class RandomGenerator in module faiss.swigfaiss

class RandomGenerator(builtins.object)
 |  RandomGenerator(seed=1234)
 |
 |  random generator that can be used in multithreaded contexts
 |
 |  Methods defined here:
 |
 |  __init__(self, seed=1234)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  rand_double(self)
 |
 |  rand_float(self)
 |      between 0 and 1
 |
 |  rand_int(self, *args)
 |      *Overload 1:*
 |      random positive integer
 |
 |      |
 |
 |      *Overload 2:*
 |      generate random integer between 0 and max-1
 |
 |  rand_int64(self)
 |      random int64_t
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RandomGenerator(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  mt
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class RandomRotationMatrix in module faiss.swigfaiss

class RandomRotationMatrix(LinearTransform)
 |  RandomRotationMatrix(*args)
 |
 |  Randomly rotate a set of vectors
 |
 |  Method resolution order:
 |      RandomRotationMatrix
 |      LinearTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      both d_in > d_out and d_out < d_in are supported
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  init(self, seed)
 |      must be called before the transform is used
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RandomRotationMatrix(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from LinearTransform:
 |
 |  apply_noalloc(self, n, x, xt)
 |      same as apply, but result is pre-allocated
 |
 |  check_identical(self, other)
 |
 |  print_if_verbose(self, name, mat, n, d)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      works only if is_orthonormal
 |
 |  set_is_orthonormal(self)
 |      compute A^T * A to set the is_orthonormal flag
 |
 |  transform_transpose(self, n, y, x)
 |      compute x = A^T * (x - b)
 |      is reverse transform if A has orthonormal lines
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from LinearTransform:
 |
 |  A
 |      Transformation matrix, size d_out * d_in
 |
 |  b
 |      bias vector, size d_out
 |
 |  have_bias
 |
 |  is_orthonormal
 |      whether to use the bias term
 |       check if matrix A is orthonormal (enables reverse_transform)
 |
 |  verbose
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class RangeQueryResult in module faiss.swigfaiss

class RangeQueryResult(builtins.object)
 |  result structure for a single query
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add(self, dis, id)
 |      called by search function to report a new result
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RangeQueryResult(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  nres
 |
 |  pres
 |
 |  qno
 |
 |  stats
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class RangeSearchPartialResult in module faiss.swigfaiss

class RangeSearchPartialResult(BufferList)
 |  RangeSearchPartialResult(res_in)
 |
 |  the entries in the buffers are split per query
 |
 |  Method resolution order:
 |      RangeSearchPartialResult
 |      BufferList
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, res_in)
 |      eventually the result will be stored in res_in
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  copy_result(self, incremental=False)
 |      called by range_search after do_allocation
 |
 |  finalize(self)
 |
 |  new_result(self, qno)
 |      begin a new result
 |
 |  set_lims(self)
 |      called by range_search before do_allocation
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RangeSearchPartialResult(...)
 |
 |  merge(partial_results, do_delete=True)
 |      merge a set of PartialResult's into one RangeSearchResult
 |      on output the partialresults are empty!
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  queries
 |      query ids + nb of results per query.
 |
 |  res
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from BufferList:
 |
 |  add(self, id, dis)
 |      add one result, possibly appending a new buffer if needed
 |
 |  append_buffer(self)
 |      create a new buffer
 |
 |  copy_range(self, ofs, n, dest_ids, dest_dis)
 |      copy elements ofs:ofs+n-1 seen as linear data in the buffers to
 |      tables dest_ids, dest_dis
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from BufferList:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  buffer_size
 |
 |  buffers
 |
 |  wp
 |      write pointer in the last buffer.

Python Library Documentation: class RangeSearchResult in module faiss.swigfaiss

class RangeSearchResult(builtins.object)
 |  RangeSearchResult(nq, alloc_lims=True)
 |
 |  The objective is to have a simple result structure while
 |  minimizing the number of mem copies in the result. The method
 |  do_allocation can be overloaded to allocate the result tables in
 |  the matrix type of a scripting language like Lua or Python.
 |
 |  Methods defined here:
 |
 |  __init__(self, nq, alloc_lims=True)
 |      lims must be allocated on input to range_search.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  do_allocation(self)
 |      called when lims contains the nb of elements result entries
 |      for each query
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RangeSearchResult(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  buffer_size
 |      size of the result buffers used
 |
 |  distances
 |      corresponding distances (not sorted)
 |
 |  labels
 |      result for query i is labels[lims[i]:lims[i+1]]
 |
 |  lims
 |      size (nq + 1)
 |
 |  nq
 |      nb of queries
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ReadOnlyInvertedLists in module faiss.swigfaiss

class ReadOnlyInvertedLists(InvertedLists)
 |  ReadOnlyInvertedLists(*args, **kwargs)
 |
 |  invlists that fail for all write functions
 |
 |  Method resolution order:
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ReadOnlyInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class RefineBeamLUTMemoryPool in module faiss.swigfaiss

class RefineBeamLUTMemoryPool(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RefineBeamLUTMemoryPool(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  codes
 |
 |  distances
 |
 |  new_codes
 |
 |  new_distances
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class RefineBeamMemoryPool in module faiss.swigfaiss

class RefineBeamMemoryPool(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RefineBeamMemoryPool(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  codes
 |
 |  distances
 |
 |  new_codes
 |
 |  new_residuals
 |
 |  residuals
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class RemapDimensionsTransform in module faiss.swigfaiss

class RemapDimensionsTransform(VectorTransform)
 |  RemapDimensionsTransform(*args)
 |
 |   remap dimensions for input vectors, possibly inserting 0s
 |  strictly speaking this is also a linear transform but we don't want
 |  to compute it with matrix multiplies
 |
 |  Method resolution order:
 |      RemapDimensionsTransform
 |      VectorTransform
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      *Overload 1:*
 |      remap input to output, skipping or inserting dimensions as needed
 |      if uniform: distribute dimensions uniformly
 |      otherwise just take the d_out first ones.
 |
 |      |
 |
 |      *Overload 2:*
 |      remap input to output, skipping or inserting dimensions as needed
 |      if uniform: distribute dimensions uniformly
 |      otherwise just take the d_out first ones.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |       apply the transformation and return the result in a provided matrix
 |      :type n: int
 |      :param n: number of vectors to transform
 |      :type x: float
 |      :param x: input vectors, size n * d_in
 |      :type xt: float
 |      :param xt: output vectors, size n * d_out
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      reverse transform correct only when the mapping is a permutation
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x) from faiss.swigfaiss.VectorTransform
 |       Perform training on a representative set of vectors. Does
 |      nothing by default.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RemapDimensionsTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  map
 |      map from output dimension to input, size d_out
 |      -1 -> set output to 0
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VectorTransform:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already

Python Library Documentation: class Repeat in module faiss.swigfaiss

class Repeat(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Repeat(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n
 |
 |  thisown
 |      The membership flag
 |
 |  val

Python Library Documentation: class RepeatVector in module faiss.swigfaiss

class RepeatVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_RepeatVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Repeats in module faiss.swigfaiss

class Repeats(builtins.object)
 |  Repeats(dim_in=0, c=None)
 |
 |  Repeats: used to encode a vector that has n occurrences of
 |  val. Encodes the signs and permutation of the vector. Useful for
 |  atoms.
 |
 |  Methods defined here:
 |
 |  __init__(self, dim_in=0, c=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  count(self)
 |
 |  decode(self, code, c)
 |
 |  encode(self, c)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Repeats(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dim
 |
 |  repeats
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class ReproduceDistancesObjective in module faiss.swigfaiss

class ReproduceDistancesObjective(PermutationObjective)
 |  ReproduceDistancesObjective(n_in, source_dis_in, target_dis_in, dis_weight_factor_in)
 |
 |  Method resolution order:
 |      ReproduceDistancesObjective
 |      PermutationObjective
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, n_in, source_dis_in, target_dis_in, dis_weight_factor_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_cost(self, perm)
 |
 |  cost_update(self, perm, iw, jw)
 |
 |  dis_weight(self, x)
 |
 |  get_source_dis(self, i, j)
 |
 |  set_affine_target_dis(self, source_dis_in)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ReproduceDistancesObjective(...)
 |
 |  compute_mean_stdev(tab, n2, mean_out, stddev_out)
 |
 |  sqr(x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  dis_weight_factor
 |
 |  source_dis
 |      "real" corrected distances (size n^2)
 |
 |  target_dis
 |      wanted distances (size n^2)
 |
 |  thisown
 |      The membership flag
 |
 |  weights
 |      weights for each distance (size n^2)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PermutationObjective:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  n

Python Library Documentation: class ResidualCoarseQuantizer in module faiss.swigfaiss

class ResidualCoarseQuantizer(AdditiveCoarseQuantizer)
 |  ResidualCoarseQuantizer(*args)
 |
 |   The ResidualCoarseQuantizer is a bit specialized compared to the
 |  default AdditiveCoarseQuantizer because it can use a beam search
 |  at search time (slow but may be useful for very large vocabularies)
 |
 |  Method resolution order:
 |      ResidualCoarseQuantizer
 |      AdditiveCoarseQuantizer
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args)
 |       Constructor.
 |
 |      :type d: int
 |      :param d:      dimensionality of the input vectors
 |      :type M: int
 |      :param M:      number of subquantizers
 |      :type nbits: int
 |      :param nbits:  number of bit per subvector index
 |
 |      :type d: int
 |      :param d: dimensionality of the input vectors
 |      :type M: int
 |      :param M: number of subquantizers
 |      :type nbits: int
 |      :param nbits: number of bit per subvector index
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  initialize_from(self, other)
 |       Copy the M first codebook levels from other. Useful to crop a
 |      ResidualQuantizer to its first M quantizers.
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |
 |  set_beam_factor(self, new_beam_factor)
 |      computes centroid norms if required
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ResidualCoarseQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  beam_factor
 |      factor between the beam size and the search k
 |      if negative, use exact search-to-centroid
 |
 |  rq
 |      The residual quantizer used to encode the vectors
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveCoarseQuantizer:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |      N/A
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids) from faiss.swigfaiss.Index
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids) from faiss.swigfaiss.Index
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1) from faiss.swigfaiss.Index
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None) from faiss.swigfaiss.Index
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons) from faiss.swigfaiss.Index
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from faiss.swigfaiss.Index
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel) from faiss.swigfaiss.Index
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  reset(self)
 |      N/A
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x) from faiss.swigfaiss.Index
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes) from faiss.swigfaiss.Index
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None) from faiss.swigfaiss.Index
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveCoarseQuantizer:
 |
 |  aq
 |
 |  centroid_norms
 |      norms of centroids, useful for knn-search
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class ResidualQuantizer in module faiss.swigfaiss

class ResidualQuantizer(AdditiveQuantizer)
 |  ResidualQuantizer(*args)
 |
 |   Residual quantizer with variable number of bits per sub-quantizer
 |
 |  The residual centroids are stored in a big cumulative centroid table.
 |  The codes are represented either as a non-compact table of size (n, M) or
 |  as the compact output (n, code_size).
 |
 |  Method resolution order:
 |      ResidualQuantizer
 |      AdditiveQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |      :type centroids: float, optional
 |      :param centroids:  centroids to be added to x, size n * d
 |
 |  initialize_from(self, other, skip_M=0)
 |      Copy the M codebook levels from other, starting from skip_M
 |
 |  memory_per_point(self, beam_size=-1)
 |       Beam search can consume a lot of memory. This function estimates the
 |      amount of mem used by refine_beam to adjust the batch size
 |
 |      :type beam_size: int, optional
 |      :param beam_size:  if != -1, override the beam size
 |
 |  refine_beam(self, n, beam_size, residuals, new_beam_size, new_codes, new_residuals=None, new_distances=None)
 |       lower-level encode function
 |
 |      :type n: int
 |      :param n:              number of vectors to handle
 |      :type residuals: float
 |      :param residuals:      vectors to encode, size (n, beam_size, d)
 |      :type beam_size: int
 |      :param beam_size:      input beam size
 |      :type new_beam_size: int
 |      :param new_beam_size:  output beam size (should be <= K * beam_size)
 |      :type new_codes: int
 |      :param new_codes:      output codes, size (n, new_beam_size, m + 1)
 |      :type new_residuals: float, optional
 |      :param new_residuals:  output residuals, size (n, new_beam_size, d)
 |      :type new_distances: float, optional
 |      :param new_distances:  output distances, size (n, new_beam_size)
 |
 |  refine_beam_LUT(self, n, query_norms, query_cp, new_beam_size, new_codes, new_distances=None)
 |
 |  retrain_AQ_codebook(self, n, x)
 |       Encode the vectors and compute codebook that minimizes the quantization
 |      error on these codes
 |
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |      :type n: int
 |      :param n:      nb of training vectors, n >= total_codebook_size
 |      :rtype: float
 |      :return: returns quantization error for the new codebook with old
 |          codes
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Train the residual quantizer
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ResidualQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  approx_topk_mode
 |      Currently used mode of approximate min-k computations.
 |      Default value is EXACT_TOPK.
 |
 |  assign_index_factory
 |      if non-NULL, use this index for assignment
 |
 |  cp
 |      clustering parameters
 |
 |  max_beam_size
 |      beam size used for training and for encoding
 |
 |  niter_codebook_refine
 |      number of iterations for codebook refinement.
 |
 |  thisown
 |      The membership flag
 |
 |  train_type
 |      Binary or of the Train_* flags below
 |
 |  use_beam_LUT
 |      use LUT for beam search
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  Skip_codebook_tables = 2048
 |
 |  Train_default = 0
 |
 |  Train_progressive_dim = 1
 |
 |  Train_refine_codebook = 2
 |
 |  Train_top_beam = 1024
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AdditiveQuantizer:
 |
 |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
 |       Compute inner-product look-up tables. Used in the centroid search
 |      functions.
 |
 |      :type xq: float
 |      :param xq:     query vector, size (n, d)
 |      :type LUT: float
 |      :param LUT:    look-up table, size (n, total_codebook_size)
 |      :type alpha: float, optional
 |      :param alpha:  compute alpha * inner-product
 |      :type ld_lut: int, optional
 |      :param ld_lut:  leading dimension of LUT
 |
 |  compute_centroid_norms(self, norms)
 |       For L2 search we need the L2 norms of the centroids
 |
 |      :type norms: float
 |      :param norms:    output norms table, size total_codebook_size
 |
 |  compute_codebook_tables(self)
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_64bit(self, n, x)
 |      decoding function for a code in a 64-bit word
 |
 |  decode_c = decode(self, codes, x, n)
 |       Decode a set of vectors
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  decode_qcint(self, c)
 |      decode norm by non-uniform scalar quantization
 |
 |  decode_unpacked(self, codes, x, n, ld_codes=-1)
 |       Decode a set of vectors in non-packed format
 |
 |      :type codes: int
 |      :param codes:  codes to decode, size n * ld_codes
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  encode_norm(self, norm)
 |      encode a norm into norm_bits bits
 |
 |  encode_qcint(self, x)
 |      encode norm by non-uniform scalar quantization
 |
 |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
 |      Exact L2 search, with precomputed norms
 |
 |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
 |      exact IP search
 |
 |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
 |       pack a series of code to bit-compact format
 |
 |      :type codes: int
 |      :param codes:        codes to be packed, size n * code_size
 |      :type packed_codes: uint8_t
 |      :param packed_codes: output bit-compact codes
 |      :type ld_codes: int, optional
 |      :param ld_codes:     leading dimension of codes
 |      :type norms: float, optional
 |      :param norms:        norms of the vectors (size n). Will be computed if
 |                              needed but not provided
 |      :type centroids: float, optional
 |      :param centroids:    centroids to be added to x, size n * d
 |
 |  set_derived_values(self)
 |      Train the norm quantizer
 |
 |  train_norm(self, n, norms)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AdditiveQuantizer:
 |
 |  M
 |      number of codebooks
 |
 |  centroid_norms
 |      norms of all codebook entries (size total_codebook_size)
 |
 |  codebook_cross_products
 |      dot products of all codebook entries with the previous codebooks
 |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
 |
 |  codebook_offsets
 |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
 |      in the codebooks table of size total_codebook_size by d
 |
 |  codebooks
 |      codebooks
 |
 |  is_trained
 |      is trained or not
 |
 |  max_mem_distances
 |      norms and distance matrixes with beam search can get large, so use this
 |      to control for the amount of memory that can be allocated
 |
 |  nbits
 |      bits for each step
 |
 |  norm_bits
 |      bits allocated for the norms
 |
 |  norm_max
 |
 |  norm_min
 |      min/max for quantization of norms
 |
 |  norm_tabs
 |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
 |      store norms of codebook entries for 4-bit fastscan
 |
 |  only_8bit
 |      are all nbits = 8 (use faster decoder)
 |
 |  qnorm
 |      store and search norms
 |
 |  search_type
 |      Also determines what's in the codes
 |
 |  tot_bits
 |      total number of bits (indexes + norms)
 |
 |  total_codebook_size
 |      size of the codebook in vectors
 |
 |  verbose
 |      verbose during training?
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from AdditiveQuantizer:
 |
 |  ST_LUT_nonorm = 1
 |
 |  ST_count = 10
 |
 |  ST_decompress = 0
 |
 |  ST_norm_cqint4 = 7
 |
 |  ST_norm_cqint8 = 6
 |
 |  ST_norm_float = 3
 |
 |  ST_norm_from_LUT = 2
 |
 |  ST_norm_lsq2x4 = 8
 |
 |  ST_norm_qint4 = 5
 |
 |  ST_norm_qint8 = 4
 |
 |  ST_norm_rq2x4 = 9
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class ResultHeap in module faiss.extra_wrappers

class ResultHeap(builtins.object)
 |  ResultHeap(nq, k, keep_max=False)
 |
 |  Accumulate query results from a sliced dataset. The final result will
 |  be in self.D, self.I.
 |
 |  Methods defined here:
 |
 |  __init__(self, nq, k, keep_max=False)
 |      nq: number of query vectors,
 |      k: number of results per query
 |      keep_max: keep the top-k maximum values instead of the minima
 |
 |  add_result(self, D, I)
 |      Add results for all heaps
 |      D, I should be of size (nh, nres)
 |      D, I do not need to be in a particular order (heap or sorted)
 |
 |  add_result_subset(self, subset, D, I)
 |      Add results for a subset of heaps.
 |      D, I should hold results for all the subset
 |      as a special case, if I is 1D, then all ids are assumed to be the same
 |
 |  finalize(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class SIMDConfig in module faiss.swigfaiss

class SIMDConfig(builtins.object)
 |  SIMDConfig(faiss_simd_level_env=None)
 |
 |  Current SIMD configuration.
 |
 |  This class provides a uniform API for querying and setting the SIMD level,
 |  regardless of whether faiss was built with Dynamic Dispatch (DD) or static
 |  SIMD selection.
 |
 |  In DD mode:
 |    - get_level() returns the runtime-detected or user-set level
 |    - set_level() changes the runtime level (if level is supported)
 |    - supported_simd_levels() returns bitmask of all compiled-in levels
 |
 |  In static mode:
 |    - get_level() returns the compiled-in level
 |    - set_level() succeeds only if level matches compiled-in level
 |    - supported_simd_levels() returns bitmask with single level
 |
 |  Methods defined here:
 |
 |  __init__(self, faiss_simd_level_env=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SIMDConfig(...)
 |
 |  auto_detect_simd_level()
 |
 |  get_dispatched_level()
 |      Returns the SIMD level via the dispatch mechanism.
 |      In DD mode, uses with_simd_level internally.
 |      In static mode, returns the compiled-in level.
 |      Useful for verification: get_level() == get_dispatched_level()
 |
 |  get_level()
 |
 |  get_level_name()
 |
 |  is_simd_level_available(level)
 |      Check if a SIMD level is available (compiled in).
 |
 |  set_level(level)
 |      Set the SIMD level. Throws FaissException if level is not supported.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  level
 |
 |  supported_simd_levels
 |      Returns bitmask of supported SIMD levels (1 << SIMDLevel).
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class ScalarQuantizer in module faiss.swigfaiss

class ScalarQuantizer(Quantizer)
 |  ScalarQuantizer(*args)
 |
 |  The uniform quantizer has a range [vmin, vmax]. The range can be
 |  the same for all dimensions (uniform) or specific per dimension
 |  (default).
 |
 |  Method resolution order:
 |      ScalarQuantizer
 |      Quantizer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Compute the codes corresponding to a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
 |
 |      Returns
 |      -------
 |      codes : array_like
 |          Corresponding code for each vector, shape (n, self.code_size)
 |          and `dtype` uint8.
 |
 |  compute_codes_c = compute_codes(self, x, codes, n)
 |       Encode a set of vectors
 |
 |      :type x: float
 |      :param x:      vectors to encode, size n * d
 |      :type codes: uint8_t
 |      :param codes:  output codes, size n * code_size
 |
 |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Reconstruct an approximation of vectors given their codes.
 |
 |      Parameters
 |      ----------
 |      codes : array_like
 |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
 |
 |      Returns
 |      -------
 |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
 |
 |  decode_c = decode(self, code, x, n)
 |       Decode a set of vectors
 |
 |      :param codes:  codes to decode, size n * code_size
 |      :type x: float
 |      :param x:      output vectors, size n * d
 |
 |  get_distance_computer(self, *args)
 |
 |  select_InvertedListScanner(self, mt, quantizer, store_pairs, sel, by_residual=False)
 |
 |  select_quantizer(self)
 |
 |  set_derived_sizes(self)
 |      updates internal values based on qtype and d
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
 |      Train the quantizer on a set of training vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ScalarQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  bits
 |      bits per scalar code
 |
 |  qtype
 |
 |  rangestat
 |
 |  rangestat_arg
 |
 |  thisown
 |      The membership flag
 |
 |  trained
 |      trained values (including the range)
 |
 |  turboq_refine
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  QT_0bit = 9
 |
 |  QT_1bit_tqmse = 10
 |
 |  QT_2bit_tq = 15
 |
 |  QT_2bit_tqmse = 11
 |
 |  QT_3bit_tq = 16
 |
 |  QT_3bit_tqmse = 12
 |
 |  QT_4bit = 1
 |
 |  QT_4bit_tq = 17
 |
 |  QT_4bit_tqmse = 13
 |
 |  QT_4bit_uniform = 3
 |
 |  QT_5bit_tq = 18
 |
 |  QT_6bit = 6
 |
 |  QT_8bit = 0
 |
 |  QT_8bit_direct = 5
 |
 |  QT_8bit_direct_signed = 8
 |
 |  QT_8bit_tqmse = 14
 |
 |  QT_8bit_uniform = 2
 |
 |  QT_bf16 = 7
 |
 |  QT_count = 19
 |
 |  QT_fp16 = 4
 |
 |  RS_meanstd = 1
 |
 |  RS_minmax = 0
 |
 |  RS_optim = 3
 |
 |  RS_quantiles = 2
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Quantizer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      bytes per indexed vector
 |
 |  d
 |      size of the input vectors

Python Library Documentation: class SearchParameters in module faiss.swigfaiss

class SearchParameters(builtins.object)
 |  SearchParameters(**args)
 |
 |   Parent class for the optional search parameters.
 |
 |  Sub-classes with additional search parameters should inherit this class.
 |  Ownership of the object fields is always to the caller.
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParameters(...)
 |      make sure we can dynamic_cast this
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class SearchParametersHNSW in module faiss.swigfaiss

class SearchParametersHNSW(SearchParameters)
 |  SearchParametersHNSW(**args)
 |
 |  Method resolution order:
 |      SearchParametersHNSW
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParametersHNSW(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  bounded_queue
 |
 |  check_relative_distance
 |
 |  efSearch
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SearchParameters:
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class SearchParametersIVF in module faiss.swigfaiss

class SearchParametersIVF(SearchParameters)
 |  SearchParametersIVF(**args)
 |
 |  Method resolution order:
 |      SearchParametersIVF
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParametersIVF(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  ensure_topk_full
 |      For k-NN search, make small early-stop budgets less aggressive:
 |      max_codes is treated as at least k post-IDSelector scans. Supported
 |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
 |      implementations 10 and 11.
 |
 |  inverted_list_context
 |      context object to pass to InvertedLists
 |
 |  max_codes
 |      max nb of codes to visit to do a query
 |
 |  max_empty_result_buckets
 |      Range-search only: stop after this many consecutive probed lists add
 |      no in-radius results. 0 disables the heuristic. This trades recall
 |      for less work. Supported in parallel_mode 0; FastScan range search
 |      uses implementation 10 for this option.
 |
 |  max_lists_num
 |      FastScan k-NN only: maximum number of inverted lists to visit.
 |      0 means unlimited, i.e. bounded only by nprobe. When set together
 |      with max_codes, either budget may stop the scan. With
 |      ensure_topk_full, this limit is treated as at least k lists.
 |
 |  nprobe
 |      number of probes at query time
 |
 |  quantizer_params
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SearchParameters:
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class SearchParametersPQ in module faiss.swigfaiss

class SearchParametersPQ(SearchParameters)
 |  SearchParametersPQ(**args)
 |
 |  override search parameters from the class
 |
 |  Method resolution order:
 |      SearchParametersPQ
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParametersPQ(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  polysemous_ht
 |
 |  search_type
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SearchParameters:
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class SearchParametersPreTransform in module faiss.swigfaiss

class SearchParametersPreTransform(SearchParameters)
 |  SearchParametersPreTransform(**args)
 |
 |  Method resolution order:
 |      SearchParametersPreTransform
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParametersPreTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  index_params
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SearchParameters:
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class SearchParametersResidualCoarseQuantizer in module faiss.swigfaiss

class SearchParametersResidualCoarseQuantizer(SearchParameters)
 |  SearchParametersResidualCoarseQuantizer(**args)
 |
 |  Method resolution order:
 |      SearchParametersResidualCoarseQuantizer
 |      SearchParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  original_init = __init__(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SearchParametersResidualCoarseQuantizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  beam_factor
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SearchParameters:
 |
 |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SearchParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  sel
 |      if non-null, only these IDs will be considered during search.

Python Library Documentation: class ShardingFunction in module faiss.swigfaiss

class ShardingFunction(builtins.object)
 |  ShardingFunction(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __call__(self, i, shard_count)
 |      Call self as a function.
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ShardingFunction(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class SignBitFactors in module faiss.swigfaiss

class SignBitFactors(builtins.object)
 |   Base factors computed per database vector for RaBitQ distance computation.
 |  Used by both 1-bit and multi-bit RaBitQ variants.
 |  These can be stored either embedded in codes (IndexRaBitQ) or separately
 |  (IndexRaBitQFastScan).
 |
 |  For 1-bit mode only - contains the minimal factors needed for distance
 |  estimation using just sign bits.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SignBitFactors(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dp_multiplier
 |
 |  or_minus_c_l2sqr
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class SignBitFactorsWithError in module faiss.swigfaiss

class SignBitFactorsWithError(SignBitFactors)
 |   Extended factors for multi-bit RaBitQ (nb_bits > 1).
 |  Includes error bound for lower bound computation in two-stage search.
 |  Inherits base factors to maintain layout compatibility.
 |
 |  Used in multi-bit mode - the error bound enables quick filtering of
 |  unlikely candidates in the first stage of two-stage search.
 |
 |  Method resolution order:
 |      SignBitFactorsWithError
 |      SignBitFactors
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SignBitFactorsWithError(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  f_error
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SignBitFactors:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dp_multiplier
 |
 |  or_minus_c_l2sqr

Python Library Documentation: class SimulatedAnnealingOptimizer in module faiss.swigfaiss

class SimulatedAnnealingOptimizer(SimulatedAnnealingParameters)
 |  SimulatedAnnealingOptimizer(obj_in, p)
 |
 |  Simulated annealing optimization algorithm for permutations.
 |
 |  Method resolution order:
 |      SimulatedAnnealingOptimizer
 |      SimulatedAnnealingParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, obj_in, p)
 |      logs values of the cost function
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  optimize(self, perm)
 |
 |  run_optimization(self, best_perm)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SimulatedAnnealingOptimizer(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  init_cost
 |      remember initial cost of optimization
 |
 |  logfile
 |
 |  n
 |      size of the permutation
 |
 |  obj
 |
 |  rnd
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SimulatedAnnealingParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  init_random
 |
 |  init_temperature
 |
 |  n_iter
 |
 |  n_redo
 |
 |  only_bit_flips
 |
 |  seed
 |
 |  temperature_decay
 |
 |  verbose

Python Library Documentation: class SimulatedAnnealingParameters in module faiss.swigfaiss

class SimulatedAnnealingParameters(builtins.object)
 |  parameters used for the simulated annealing method
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SimulatedAnnealingParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  init_random
 |
 |  init_temperature
 |
 |  n_iter
 |
 |  n_redo
 |
 |  only_bit_flips
 |
 |  seed
 |
 |  temperature_decay
 |
 |  thisown
 |      The membership flag
 |
 |  verbose

Python Library Documentation: class SliceInvertedLists in module faiss.swigfaiss

class SliceInvertedLists(ReadOnlyInvertedLists)
 |  SliceInvertedLists(il_, i0_, i1_)
 |
 |  vertical slice of indexes in another InvertedLists
 |
 |  Method resolution order:
 |      SliceInvertedLists
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, il_, i0_, i1_)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SliceInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  i0
 |
 |  i1
 |
 |  il
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ReadOnlyInvertedLists:
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class SlidingIndexWindow in module faiss.swigfaiss

class SlidingIndexWindow(builtins.object)
 |  SlidingIndexWindow(index)
 |
 |   A set of IndexIVFs concatenated together in a FIFO fashion.
 |  at each "step", the oldest index slice is removed and a new index is added.
 |
 |  Methods defined here:
 |
 |  __init__(self, index)
 |      index should be initially empty and trained
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  step(self, sub_index, remove_oldest)
 |       Add one index to the current index and remove the oldest one.
 |
 |      :type sub_index: :py:class:`Index`
 |      :param sub_index:        slice to swap in (can be NULL)
 |      :type remove_oldest: boolean
 |      :param remove_oldest:    if true, remove the oldest slices
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SlidingIndexWindow(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ils
 |      InvertedLists of index
 |
 |  index
 |      common index that contains the sliding window
 |
 |  n_slice
 |      number of slices currently in index
 |
 |  nlist
 |      same as index->nlist
 |
 |  sizes
 |      cumulative list sizes at each slice
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class SplitMix64RandomGenerator in module faiss.swigfaiss

class SplitMix64RandomGenerator(builtins.object)
 |  SplitMix64RandomGenerator(seed=1234)
 |
 |  fast random generator that cannot be used in multithreaded contexts.
 |  based on https://prng.di.unimi.it/
 |
 |  Methods defined here:
 |
 |  __init__(self, seed=1234)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  next(self)
 |
 |  rand_double(self)
 |
 |  rand_float(self)
 |      between 0 and 1
 |
 |  rand_int(self, *args)
 |      *Overload 1:*
 |      random positive integer
 |
 |      |
 |
 |      *Overload 2:*
 |      generate random integer between 0 and max-1
 |
 |  rand_int64(self)
 |      random int64_t
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SplitMix64RandomGenerator(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  state
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class StopWordsInvertedLists in module faiss.swigfaiss

class StopWordsInvertedLists(ReadOnlyInvertedLists)
 |  StopWordsInvertedLists(il0_in, maxsize_in)
 |
 |  if the inverted list in il is smaller than maxsize then return it,
 |  otherwise return an empty invlist
 |
 |  Method resolution order:
 |      StopWordsInvertedLists
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, il0_in, maxsize_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_StopWordsInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  il0
 |
 |  maxsize
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ReadOnlyInvertedLists:
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class SuperKMeans in module faiss.swigfaiss

class SuperKMeans(builtins.object)
 |  SuperKMeans(*args)
 |
 |   Drop-in faster k-means: same interface as faiss::Clustering. Per iteration:
 |    iter 0:           full GEMM over all d dims (vanilla Lloyd's).
 |    iter 1..niter-1:  GEMM over front d_prime dims, then ADSampling
 |                      progressive pruning over PDX-laid trailing dims.
 |
 |  Trains in a randomly-rotated space; centroids are un-rotated before return.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_SuperKMeans.<locals>
 |      Perform SuperKMeans clustering on a set of vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, self.d). `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |      Train on `n` row-major vectors of dimension `d`. Honors the applicable
 |      ClusteringParameters fields (niter, seed, verbose,
 |      max_points_per_centroid, use_faster_subsampling,
 |      check_input_data_for_NaNs).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SuperKMeans(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  centroids
 |      Output: k * d floats, row-major, un-rotated.
 |
 |  cp
 |
 |  d
 |
 |  gemm_pruning_rates
 |      Per-iter fraction of (vector, centroid) pairs pruned at the d_prime
 |      GEMM-boundary chi-squared check. Per-PDX-block early-exits are NOT
 |      counted. iter 0 uses full GEMM, so gemm_pruning_rates[0] == 0.0f.
 |
 |  iteration_stats
 |      Per-iter stats. `obj`, `time`, and `nsplit` are populated faithfully.
 |      `time_search` mirrors `time` (phases not timed separately) and
 |      `imbalance_factor` is set to NaN (not computed).
 |
 |  k
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class SuperKMeansParameters in module faiss.swigfaiss

class SuperKMeansParameters(ClusteringParameters)
 |  Method resolution order:
 |      SuperKMeansParameters
 |      ClusteringParameters
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SuperKMeansParameters(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  ad_epsilon_factor
 |      ADSampling significance: epsilon = ad_epsilon_factor / d.
 |
 |  d_prime_adjust
 |      Relative step size for d_prime adjustments.
 |
 |  d_prime_fraction
 |      Initial d_prime as a fraction of d (GEMM/PRUNING split).
 |
 |  d_prime_min
 |      Floor on d_prime; below this the chi-squared bound is unvalidated.
 |
 |  omp_chunk
 |      OpenMP dynamic-schedule chunk size for the pruning loop.
 |
 |  pdx_block_size
 |      Matches block_l2 SIMD width.
 |
 |  pruning_target_high
 |
 |  pruning_target_low
 |      Adaptive d_prime stay-in-band controller. Per iteration:
 |        pruning > high → shrink d_prime  (over-pruning, cheaper threshold)
 |        pruning < low  → grow   d_prime  (under-pruning, more GEMM work)
 |        else: hold.
 |
 |  thisown
 |      The membership flag
 |
 |  x_batch
 |
 |  y_batch
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ClusteringParameters:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  afkmc2_chain_length
 |      Chain length for AFK-MC² initialization.
 |      Only used when init_method = AFK_MC2.
 |      Longer chains give better approximation but are slower.
 |
 |  check_input_data_for_NaNs
 |      whether to check for NaNs in an input data
 |
 |  decode_block_size
 |      when the training set is encoded, batch size of the codec decoder
 |
 |  early_stop_threshold
 |      Early stop threshold, the range is [0, 1].
 |      The value of 0 implies a default Faiss behavior,
 |      so the training process stops only if an error
 |      is unchanged from the previous iteration.
 |
 |  frozen_centroids
 |      Use the subset of centroids provided as input and do not change them
 |      during iterations
 |
 |  init_method
 |      Initialization method for centroids.
 |      RANDOM: uniform random sampling (default, current behavior)
 |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
 |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
 |
 |  int_centroids
 |      round centroids coordinates to integer after each iteration?
 |
 |  max_points_per_centroid
 |      to limit size of dataset, otherwise the training set is subsampled
 |
 |  min_points_per_centroid
 |      If fewer than this number of training vectors per centroid are provided,
 |      writes a warning. Note that fewer than 1 point per centroid raises an
 |      exception.
 |
 |  niter
 |      number of clustering iterations
 |
 |  nredo
 |      redo clustering this many times and keep the clusters with the best
 |      objective
 |
 |  seed
 |      seed for the random number generator.
 |      negative values lead to seeding an internal rng with
 |      std::high_resolution_clock.
 |
 |  spherical
 |      whether to normalize centroids after each iteration (useful for inner
 |      product clustering)
 |
 |  update_index
 |      re-train index after each iteration?
 |
 |  use_faster_subsampling
 |      Whether to use splitmix64-based random number generator for subsampling,
 |      which is faster, but may pick duplicate points.
 |
 |  verbose

Python Library Documentation: class SuperKmeans in module faiss.extra_wrappers

class SuperKmeans(Kmeans)
 |  SuperKmeans(d, k, **kwargs)
 |
 |  Drop-in replacement for `Kmeans` that runs `SuperKMeans` (ADSampling +
 |  PDX progressive pruning) instead of `Clustering`. Same `centroids`, `obj`,
 |  `iteration_stats`, and `assign()` surface; additionally exposes
 |  `gemm_pruning_rates`.
 |
 |  kwargs are forwarded to `SuperKMeansParameters`. Fields not present on it
 |  (e.g. `spherical`, `int_centroids`, `nredo`, `frozen_centroids`,
 |  `init_method`, `update_index`, `early_stop_threshold`,
 |  `progressive_dim_steps`, `gpu`) raise `AttributeError`.
 |
 |  Method resolution order:
 |      SuperKmeans
 |      Kmeans
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, d, k, **kwargs)
 |      d: input dimension, k: nb of centroids. Additional
 |      parameters are passed on the ClusteringParameters object,
 |      including niter=25, verbose=False, spherical = False
 |
 |  set_index(self)
 |
 |  train(self, x, weights=None, init_centroids=None)
 |      Perform k-means clustering.
 |      On output of the function call:
 |
 |      - the centroids are in the centroids field of size (`k`, `d`).
 |
 |      - the objective value at each iteration is in the array obj (size `niter`)
 |
 |      - detailed optimization statistics are in the array iteration_stats.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Training vectors, shape (n, d), `dtype` must be float32 and n should
 |          be larger than the number of clusters `k`.
 |      weights : array_like
 |          weight associated to each vector, shape `n`
 |      init_centroids : array_like
 |          initial set of centroids, shape (n, d)
 |
 |      Returns
 |      -------
 |      final_obj: float
 |          final optimization objective
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Kmeans:
 |
 |  assign(self, x)
 |
 |  reset(self, k=None)
 |      prepare k-means object to perform a new clustering, possibly
 |      with another number of centroids
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Kmeans:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class SwigPyIterator in module faiss.swigfaiss

class SwigPyIterator(builtins.object)
 |  SwigPyIterator(*args, **kwargs)
 |
 |  Methods defined here:
 |
 |  __add__(self, n)
 |
 |  __eq__(self, x)
 |      Return self==value.
 |
 |  __iadd__(self, n)
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __isub__(self, n)
 |
 |  __iter__(self)
 |
 |  __ne__(self, x)
 |      Return self!=value.
 |
 |  __next__(self)
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __sub__(self, *args)
 |
 |  advance(self, n)
 |
 |  copy(self)
 |
 |  decr(self, n=1)
 |
 |  distance(self, x)
 |
 |  equal(self, x)
 |
 |  incr(self, n=1)
 |
 |  next(self)
 |
 |  previous(self)
 |
 |  value(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_SwigPyIterator(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Python Library Documentation: class Tensor2D in module faiss.swigfaiss

class Tensor2D(builtins.object)
 |  Tensor2D(*args)
 |
 |  Implements a few neural net layers, mainly to support QINCo
 |
 |  Methods defined here:
 |
 |  __iadd__(self, arg2)
 |
 |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Tensor2D.<locals>
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  column(self, j)
 |      get column #j as a 1-column Tensor2D
 |
 |  data(self, *args)
 |
 |  numel(self)
 |
 |  numpy(self) from faiss.class_wrappers.handle_Tensor2D.<locals>
 |
 |  original_init = __init__(self, n0, n1, data=None)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_Tensor2D(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  shape
 |
 |  thisown
 |      The membership flag
 |
 |  v

Python Library Documentation: class ThreadedIndexBase in module faiss.swigfaiss

class ThreadedIndexBase(Index)
 |  ThreadedIndexBase(*args, **kwargs)
 |
 |  A holder of indices in a collection of threads
 |  The interface to this class itself is not thread safe
 |
 |  Method resolution order:
 |      ThreadedIndexBase
 |      Index
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  addIndex(self, index)
 |      override an index that is managed by ourselves.
 |      WARNING: once an index is added, it becomes unsafe to touch it from any
 |      other thread than that on which is managing it, until we are shut
 |      down. Use runOnIndex to perform work on it instead.
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ThreadedIndexBase(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Index:
 |
 |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors to the index.
 |      The index must be trained before vectors can be added to it.
 |      The vectors are implicitly numbered in sequence. When `n` vectors are
 |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  add_c = add(self, n, x)
 |       Add n vectors of dimension d to the index.
 |
 |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
 |      This function slices the input vectors in chunks smaller than
 |      blocksize_add and calls add_core.
 |      :type n: int
 |      :param n:      number of vectors
 |      :type x: float
 |      :param x:      input matrix, size n * d
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
 |       Add vectors that are computed with the standalone codec
 |
 |      :type codes: uint8_t
 |      :param codes:  codes to add size n * sa_code_size()
 |      :type xids: int
 |      :param xids:   corresponding ids, size n
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Adds vectors with arbitrary ids to the index (not all indexes support this).
 |      The index must be trained before vectors can be added to it.
 |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      ids : array_like
 |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
 |          in result lists to mean "not found" so it's better to not use it as an id.
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:         number of vectors
 |      :type x: float
 |      :param x:         input vectors, size n * d
 |      :type xids: int
 |      :param xids:      if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical as search but only return labels of
 |      neighbors.
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type k: int, optional
 |      :param k:           number of nearest neighbours
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  compute_residual(self, x, residual, key)
 |       Computes a residual vector after indexing encoding.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type x: float
 |      :param x:           input vector, size d
 |      :type residual: float
 |      :param residual:    output residual vector, size d
 |      :type key: int
 |      :param key:         encoded index, as returned by search and assign
 |
 |  compute_residual_n(self, n, xs, residuals, keys)
 |       Computes a residual vector after indexing encoding (batch form).
 |      Equivalent to calling compute_residual for each vector.
 |
 |      The residual vector is the difference between a vector and the
 |      reconstruction that can be decoded from its representation in
 |      the index. The residual can be used for multiple-stage indexing
 |      methods, like IndexIVF's methods.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type xs: float
 |      :param xs:          input vectors, size (n x d)
 |      :type residuals: float
 |      :param residuals:   output residual vectors, size (n x d)
 |      :type keys: int
 |      :param keys:        encoded index, as returned by search and assign
 |
 |  get_distance_computer(self)
 |       Get a DistanceComputer (defined in AuxIndexStructures) object
 |      for this kind of index.
 |
 |      DistanceComputer is implemented for indexes that support random
 |      access of their vectors.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Search vectors that are within a distance of the query vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      thresh : float
 |          Threshold to select neighbors. All elements within this radius are returned,
 |          except for maximum inner product indexes, where the elements above the
 |          threshold are returned
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |
 |
 |      Returns
 |      -------
 |      lims: array_like
 |          Starting index of the results for each query vector, size n+1.
 |      D : array_like
 |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
 |          query i are in `D[lims[i]:lims[i+1]]`.
 |      I : array_like
 |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
 |          are in `I[lims[i]:lims[i+1]]`.
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many
 |      indexes do not implement the range_search (only the k-NN search
 |      is mandatory).
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type radius: float
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of one vector from the index.
 |
 |      Parameters
 |      ----------
 |      key : int
 |          Id of the vector to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
 |
 |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of several vectors from the index.
 |
 |      Parameters
 |      ----------
 |      key : array of ints
 |          Ids of the vectors to reconstruct
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          reconstrcuted vectors, size `len(key), self.d`
 |
 |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
 |       Reconstruct several stored vectors (or an approximation if lossy
 |      coding)
 |
 |      this function may not be defined for some indexes
 |      :type n: int
 |      :param n:           number of vectors to reconstruct
 |      :type keys: int
 |      :param keys:        ids of the vectors to reconstruct (size n)
 |      :type recons: float
 |      :param recons:      reconstructed vector (size n * d)
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector (or an approximation if lossy coding)
 |
 |      this function may not be defined for some indexes
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: float
 |      :param recons:      reconstructed vector (size d)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
 |      Missing vectors trigger an exception.
 |
 |      Parameters
 |      ----------
 |      n0 : int
 |          Id of the first vector to reconstruct (default 0)
 |      ni : int
 |          Number of vectors to reconstruct (-1 = default = ntotal)
 |      x : array_like, optional
 |          pre-allocated array to store the results
 |
 |      Returns
 |      -------
 |      x : array_like
 |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1
 |
 |      this function may not be defined for some indexes
 |      :type i0: int
 |      :param i0:          index of the first vector in the sequence
 |      :type ni: int
 |      :param ni:          number of vectors in the sequence
 |      :type recons: float
 |      :param recons:      reconstructed vector (size ni * d)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
 |      Remove some ids from the index.
 |      This is a O(ntotal) operation by default, so could be expensive.
 |
 |      Parameters
 |      ----------
 |      x : array_like or faiss.IDSelector
 |          Either an IDSelector that returns True for vectors to remove, or a
 |          list of ids to reomove (1D array of int64). When `x` is a list,
 |          it is wrapped into an IDSelector.
 |
 |      Returns
 |      -------
 |      n_remove: int
 |          number of vectors that were removed
 |
 |  remove_ids_c = remove_ids(self, sel)
 |       removes IDs from the index. Not supported by all
 |      indexes. Returns the number of elements removed.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_decode_c = sa_decode(self, n, bytes, x)
 |       decode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type bytes: uint8_t
 |      :param bytes:   input encoded vectors, size n * sa_code_size()
 |      :type x: float
 |      :param x:       output vectors, size n * d
 |
 |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
 |
 |  sa_encode_c = sa_encode(self, n, x, bytes)
 |       encode a set of vectors
 |
 |      :type n: int
 |      :param n:       number of vectors
 |      :type x: float
 |      :param x:       input vectors, size n * d
 |      :type bytes: uint8_t
 |      :param bytes:   output encoded vectors, size n * sa_code_size()
 |
 |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  search1(self, x, handler, params=None)
 |      search one vector with a custom result handler
 |
 |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index,
 |      and return an approximation of these vectors.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be float32.
 |      k : int
 |          Number of nearest neighbors.
 |      params : SearchParameters
 |          Search parameters of the current search (overrides the class-level params)
 |      D : array_like, optional
 |          Distance array to store the result.
 |      I : array_like, optional
 |          Labels array to store the result.
 |      R : array_like, optional
 |          reconstruction array to store
 |
 |      Returns
 |      -------
 |      D : array_like
 |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
 |          the label is set to +Inf or -Inf.
 |      I : array_like
 |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
 |          the label is set to -1
 |      R : array_like
 |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
 |
 |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting arrays
 |      is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type recons: float
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       query n vectors of dimension d to the index.
 |
 |      return at most k vectors. If there are not enough results for a
 |      query, the result array is padded with -1s.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors to search, size n * d
 |      :type k: int
 |      :param k:           number of extracted vectors
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
 |       Similar to search, but operates on a potentially different subset
 |      of the dataset for each query.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type n: int
 |      :param n:           number of vectors
 |      :type x: float
 |      :param x:           input vectors, size n * d
 |      :type k_base: int
 |      :param k_base:      number of vectors to search from
 |      :type base_labels: int
 |      :param base_labels: ids of the vectors to search from
 |      :type k: int
 |      :param k:           desired number of results per query
 |      :type distances: float
 |      :param distances:   output pairwise distances, size n*k
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
 |      Trains the index on a representative set of vectors.
 |      The index must be trained before vectors can be added to it.
 |      Optionally accepts numeric_type to specify the type of
 |      input vectors.
 |      Optionally accepts a set of training query vectors for
 |      out-of-distribution training.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate
 |          for the index. `dtype` must be float32.
 |      numeric_type : type
 |          Numeric type of the input vectors.
 |      xq_train : array_like, optional
 |          Training query vectors, shape (n_train_q, d) where
 |          d is appropriate for the index.
 |          `dtype` must be float32.
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  train_with_queries(self, n, x, n_train_q, xq_train)
 |       Perform training on a representative set of vectors and a representative
 |      set of queries
 |
 |      :type n: int
 |      :param n:         nb of training vectors
 |      :type x: float
 |      :param x:         training vectors, size n * d
 |      :type n_train_q: int
 |      :param n_train_q: nb of training queries
 |      :type xq_train: float
 |      :param xq_train:  training queries, size n_train_q * d
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Index:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is
 |      done already
 |
 |  metric_arg
 |      argument of the metric type
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class ThreadedIndexBaseBinary in module faiss.swigfaiss

class ThreadedIndexBaseBinary(IndexBinary)
 |  ThreadedIndexBaseBinary(*args, **kwargs)
 |
 |  A holder of indices in a collection of threads
 |  The interface to this class itself is not thread safe
 |
 |  Method resolution order:
 |      ThreadedIndexBaseBinary
 |      IndexBinary
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  addIndex(self, index)
 |      override an index that is managed by ourselves.
 |      WARNING: once an index is added, it becomes unsafe to touch it from any
 |      other thread than that on which is managing it, until we are shut
 |      down. Use runOnIndex to perform work on it instead.
 |
 |  at(self, *args)
 |      *Overload 1:*
 |      Returns the i-th sub-index
 |
 |      |
 |
 |      *Overload 2:*
 |      Returns the i-th sub-index (const version)
 |
 |  count(self)
 |      Returns the number of sub-indices
 |
 |  removeIndex(self, index)
 |      Remove an index that is managed by ourselves.
 |      This will flush all pending work on that index, and then shut
 |      down its managing thread, and will remove the index.
 |
 |  reset(self)
 |      faiss::Index API
 |      All indices receive the same call
 |
 |  runOnIndex(self, *args)
 |      Run a function on all indices, in the thread that the index is
 |      managed in.
 |      Function arguments are (index in collection, index pointer)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ThreadedIndexBaseBinary(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  own_indices
 |      Whether or not we are responsible for deleting our contained indices
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IndexBinary:
 |
 |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_c = add(self, n, x)
 |       Add n vectors of dimension d to the index.
 |
 |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
 |      :type x: uint8_t
 |      :param x:      input matrix, size n * d / 8
 |
 |  add_ex(self, n, x, numeric_type)
 |
 |  add_sa_codes(self, n, codes, xids)
 |      Same as add_with_ids for IndexBinary.
 |
 |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  add_with_ids_c = add_with_ids(self, n, x, xids)
 |       Same as add, but stores xids instead of sequential ids.
 |
 |      The default implementation fails with an assertion, as it is
 |      not supported by all indexes.
 |
 |      :type xids: int
 |      :param xids: if non-null, ids to store for the vectors (size n)
 |
 |  add_with_ids_ex(self, n, x, numeric_type, xids)
 |
 |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |      Find the k nearest neighbors of the set of vectors x in the index.
 |      This is the same as the `search` method, but discards the distances.
 |
 |      Parameters
 |      ----------
 |      x : array_like
 |          Query vectors, shape (n, d) where d is appropriate for the index.
 |          `dtype` must be uint8.
 |      k : int
 |          Number of nearest neighbors.
 |      labels : array_like, optional
 |          Labels array to store the results.
 |
 |      Returns
 |      -------
 |      labels: array_like
 |          Labels of the nearest neighbors, shape (n, k).
 |          When not enough results are found, the label is set to -1
 |
 |  assign_c = assign(self, n, x, labels, k=1)
 |       Return the indexes of the k vectors closest to the query x.
 |
 |      This function is identical to search but only returns labels of
 |      neighbors.
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |
 |  check_compatible_for_merge(self, otherIndex)
 |       check that the two indexes are compatible (ie, they are
 |      trained in the same way and have the same
 |      parameters). Otherwise throw.
 |
 |  display(self)
 |      Display the actual class name and some more info.
 |
 |  merge_from(self, otherIndex, add_id=0)
 |       moves the entries from another dataset to self.
 |      On output, other is empty.
 |      add_id is added to all moved ids
 |      (for sequential ids, this would be this->ntotal)
 |
 |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  range_search_c = range_search(self, n, x, radius, result, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return all vectors with distance < radius. Note that many indexes
 |      do not implement the range_search (only the k-NN search is
 |      mandatory). The distances are converted to float to reuse the
 |      RangeSearchResult structure, but they are integer. By convention,
 |      only distances < radius (strict comparison) are returned,
 |      ie. radius = 0 does not return any result and 1 returns only
 |      exact same vectors.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type radius: int
 |      :param radius:      search radius
 |      :type result: :py:class:`RangeSearchResult`
 |      :param result:      result table
 |
 |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_c = reconstruct(self, key, recons)
 |       Reconstruct a stored vector.
 |
 |      This function may not be defined for some indexes.
 |      :type key: int
 |      :param key:         id of the vector to reconstruct
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vector (size d / 8)
 |
 |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
 |       Reconstruct vectors i0 to i0 + ni - 1.
 |
 |      This function may not be defined for some indexes.
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors (size ni * d / 8)
 |
 |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  remove_ids_c = remove_ids(self, sel)
 |      Removes IDs from the index. Not supported by all indexes.
 |
 |  sa_code_size(self)
 |      size of the produced codes in bytes
 |
 |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
 |       Similar to search, but also reconstructs the stored vectors (or an
 |      approximation in the case of lossy coding) for the search results.
 |
 |      If there are not enough results for a query, the resulting array
 |      is padded with -1s.
 |
 |      :type recons: uint8_t
 |      :param recons:      reconstructed vectors size (n, k, d)
 |
 |  search_c = search(self, n, x, k, distances, labels, params=None)
 |       Query n vectors of dimension d to the index.
 |
 |      return at most k vectors. If there are not enough results for a
 |      query, the result array is padded with -1s.
 |
 |      :type x: uint8_t
 |      :param x:           input vectors to search, size n * d / 8
 |      :type labels: int
 |      :param labels:      output labels of the NNs, size n*k
 |      :type distances: int
 |      :param distances:   output pairwise distances, size n*k
 |
 |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
 |
 |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: uint8_t
 |      :param x:      training vectors, size n * d / 8
 |
 |  train_ex(self, n, x, numeric_type)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IndexBinary:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      number of bytes per vector ( = d / 8 )
 |
 |  d
 |      vector dimension
 |
 |  is_trained
 |      set if the Index does not require training, or if training is done
 |      already
 |
 |  metric_type
 |      type of metric this index uses for search
 |
 |  ntotal
 |      total nb of indexed vectors
 |
 |  verbose
 |      verbosity level

Python Library Documentation: class TimeoutCallback in module faiss.swigfaiss

class TimeoutCallback(InterruptCallback)
 |  Method resolution order:
 |      TimeoutCallback
 |      InterruptCallback
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  set_timeout(self, timeout_in_seconds)
 |
 |  want_interrupt(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_TimeoutCallback(...)
 |
 |  reset(timeout_in_seconds)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  start
 |
 |  thisown
 |      The membership flag
 |
 |  timeout
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from InterruptCallback:
 |
 |  check()
 |       check if:
 |      - an interrupt callback is set
 |      - the callback returns true
 |      if this is the case, then throw an exception. Should not be called
 |      from multiple threads.
 |
 |  clear_instance()
 |
 |  get_period_hint(flops)
 |       assuming each iteration takes a certain number of flops, what
 |      is a reasonable interval to check for interrupts?
 |
 |  is_interrupted()
 |      same as check() but return true if is interrupted instead of
 |      throwing. Can be called from multiple threads.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InterruptCallback:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class TimeoutGuard in module faiss

class TimeoutGuard(builtins.object)
 |  TimeoutGuard(timeout_in_seconds: float)
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, exc_type, exc_value, traceback)
 |
 |  __init__(self, timeout_in_seconds: float)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class UInt16Vector in module faiss.swigfaiss

class UInt16Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_UInt16Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class UInt32Vector in module faiss.swigfaiss

class UInt32Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_UInt32Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class UInt64Vector in module faiss.swigfaiss

class UInt64Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_UInt64Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: class UInt8Vector in module faiss.swigfaiss

class UInt8Vector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_UInt8Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class UInt8VectorVector in module faiss.swigfaiss

class UInt8VectorVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_UInt8VectorVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Uint64Vector in module faiss.array_conversions

class Uint64Vector(faiss.swigfaiss.UInt64Vector)
 |  Uint64Vector(*args, **kwargs)
 |
 |  Method resolution order:
 |      Uint64Vector
 |      faiss.swigfaiss.UInt64Vector
 |      builtins.object
 |
 |  Static methods defined here:
 |
 |  __new__ = new_meth(cls, *args, **kwargs) from faiss.array_conversions._make_deprecated_swig_class.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from faiss.swigfaiss.UInt64Vector:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from faiss.swigfaiss.UInt64Vector:
 |
 |  __swig_destroy__ = delete_UInt64Vector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from faiss.swigfaiss.UInt64Vector:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Error rendering doc: No Python documentation found for '1.14.3'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

Python Library Documentation: class VStackInvertedLists in module faiss.swigfaiss

class VStackInvertedLists(ReadOnlyInvertedLists)
 |  VStackInvertedLists(n_il, ils)
 |
 |  Method resolution order:
 |      VStackInvertedLists
 |      ReadOnlyInvertedLists
 |      InvertedLists
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, n_il, ils)
 |      build InvertedLists by concatenating nil of them
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  get_codes(self, list_no)
 |       get the codes for an inverted list
 |      must be released by release_codes
 |
 |      :rtype: uint8_t
 |      :return: codes    size list_size * code_size
 |
 |  get_ids(self, list_no)
 |       get the ids for an inverted list
 |      must be released by release_ids
 |
 |      :rtype: int
 |      :return: ids      size list_size
 |
 |  get_single_code(self, list_no, offset)
 |      :rtype: uint8_t
 |      :return: a single code in an inverted list
 |          (should be deallocated with release_codes)
 |
 |  get_single_id(self, list_no, offset)
 |      :rtype: int
 |      :return: a single id in an inverted list
 |
 |  list_size(self, list_no)
 |      get the size of a list
 |
 |  prefetch_lists(self, list_nos, nlist_in)
 |      prepare the following lists (default does nothing)
 |      a list can be -1 hence the signed long
 |
 |  release_codes(self, list_no, codes)
 |      release codes returned by get_codes (default implementation is nop
 |
 |  release_ids(self, list_no, ids)
 |      release ids returned by get_ids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VStackInvertedLists(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  cumsz
 |
 |  ils
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ReadOnlyInvertedLists:
 |
 |  add_entries(self, list_no, n_entry, ids, code)
 |
 |  resize(self, list_no, new_size)
 |
 |  update_entries(self, list_no, offset, n_entry, ids, code)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from InvertedLists:
 |
 |  add_entry(self, list_no, theid, code, inverted_list_context=None)
 |      add one entry to an inverted list
 |
 |  compute_ntotal(self)
 |      sum up list sizes
 |
 |  copy_subset_to(self, other, subset_type, a1, a2)
 |       copy a subset of the entries index to the other index
 |      :rtype: int
 |      :return: number of entries copied
 |
 |  get_iterator(self, list_no, inverted_list_context=None)
 |      get iterable for lists that use_iterator
 |
 |  imbalance_factor(self)
 |      1= perfectly balanced, >1: imbalanced
 |
 |  is_empty(self, list_no, inverted_list_context=None)
 |      check if the list is empty
 |
 |  merge_from(self, oivf, add_id)
 |      move all entries from oivf (empty on output)
 |
 |  print_stats(self)
 |      display some stats about the inverted lists
 |
 |  reset(self)
 |
 |  update_entry(self, list_no, offset, id, code)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from InvertedLists:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  code_size
 |      code size per vector in bytes
 |
 |  nlist
 |      number of possible key values
 |
 |  use_iterator
 |      request to use iterator rather than get_codes / get_ids
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from InvertedLists:
 |
 |  INVALID_CODE_SIZE = 18446744073709551615
 |
 |  SUBSET_TYPE_ELEMENT_RANGE = 2
 |
 |  SUBSET_TYPE_ID_MOD = 1
 |
 |  SUBSET_TYPE_ID_RANGE = 0
 |
 |  SUBSET_TYPE_INVLIST = 4
 |
 |  SUBSET_TYPE_INVLIST_FRACTION = 3

Python Library Documentation: class VectorIOReader in module faiss.swigfaiss

class VectorIOReader(IOReader)
 |  Method resolution order:
 |      VectorIOReader
 |      IOReader
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VectorIOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  data
 |
 |  rp
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOReader:
 |
 |  filedescriptor(self)
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOReader:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class VectorIOWriter in module faiss.swigfaiss

class VectorIOWriter(IOWriter)
 |  Method resolution order:
 |      VectorIOWriter
 |      IOWriter
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VectorIOWriter(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  data
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOWriter:
 |
 |  filedescriptor(self)
 |
 |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOWriter:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class VectorTransform in module faiss.swigfaiss

class VectorTransform(builtins.object)
 |  VectorTransform(*args, **kwargs)
 |
 |  Any transformation applied on a set of vectors
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  apply_noalloc(self, n, x, xt)
 |       apply the transformation and return the result in a provided matrix
 |      :type n: int
 |      :param n: number of vectors to transform
 |      :type x: float
 |      :param x: input vectors, size n * d_in
 |      :type xt: float
 |      :param xt: output vectors, size n * d_out
 |
 |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  check_identical(self, other)
 |
 |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  reverse_transform_c = reverse_transform(self, n, xt, x)
 |      reverse transformation. May not be implemented or may return
 |      approximate result
 |
 |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
 |
 |  train_c = train(self, n, x)
 |       Perform training on a representative set of vectors. Does
 |      nothing by default.
 |
 |      :type n: int
 |      :param n:      nb of training vectors
 |      :type x: float
 |      :param x:      training vectors, size n * d
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VectorTransform(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  d_in
 |
 |  d_out
 |      input dimension
 |
 |  is_trained
 |      set if the VectorTransform does not require training, or if
 |      training is done already
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class VectorTransformVector in module faiss.swigfaiss

class VectorTransformVector(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  at(self, n)
 |
 |  clear(self)
 |
 |  data(self)
 |
 |  push_back(self, arg2)
 |
 |  resize(self, n)
 |
 |  size(self)
 |
 |  swap(self, other)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VectorTransformVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class Version in module packaging.version

class Version(_BaseVersion)
 |  Version(version: 'str') -> 'None'
 |
 |  This class abstracts handling of a project's versions.
 |
 |  A :class:`Version` instance is comparison aware and can be compared and
 |  sorted using the standard Python interfaces.
 |
 |  >>> v1 = Version("1.0a5")
 |  >>> v2 = Version("1.0")
 |  >>> v1
 |  <Version('1.0a5')>
 |  >>> v2
 |  <Version('1.0')>
 |  >>> v1 < v2
 |  True
 |  >>> v1 == v2
 |  False
 |  >>> v1 > v2
 |  False
 |  >>> v1 >= v2
 |  False
 |  >>> v1 <= v2
 |  True
 |
 |  Method resolution order:
 |      Version
 |      _BaseVersion
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, version: 'str') -> 'None'
 |      Initialize a Version object.
 |
 |      :param version:
 |          The string representation of a version which will be parsed and normalized
 |          before use.
 |      :raises InvalidVersion:
 |          If the ``version`` does not conform to PEP 440 in any way then this
 |          exception will be raised.
 |
 |  __repr__(self) -> 'str'
 |      A representation of the Version that shows all internal state.
 |
 |      >>> Version('1.0.0')
 |      <Version('1.0.0')>
 |
 |  __str__(self) -> 'str'
 |      A string representation of the version that can be rounded-tripped.
 |
 |      >>> str(Version("1.0a5"))
 |      '1.0a5'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  base_version
 |      The "base version" of the version.
 |
 |      >>> Version("1.2.3").base_version
 |      '1.2.3'
 |      >>> Version("1.2.3+abc").base_version
 |      '1.2.3'
 |      >>> Version("1!1.2.3+abc.dev1").base_version
 |      '1!1.2.3'
 |
 |      The "base version" is the public version of the project without any pre or post
 |      release markers.
 |
 |  dev
 |      The development number of the version.
 |
 |      >>> print(Version("1.2.3").dev)
 |      None
 |      >>> Version("1.2.3.dev1").dev
 |      1
 |
 |  epoch
 |      The epoch of the version.
 |
 |      >>> Version("2.0.0").epoch
 |      0
 |      >>> Version("1!2.0.0").epoch
 |      1
 |
 |  is_devrelease
 |      Whether this version is a development release.
 |
 |      >>> Version("1.2.3").is_devrelease
 |      False
 |      >>> Version("1.2.3.dev1").is_devrelease
 |      True
 |
 |  is_postrelease
 |      Whether this version is a post-release.
 |
 |      >>> Version("1.2.3").is_postrelease
 |      False
 |      >>> Version("1.2.3.post1").is_postrelease
 |      True
 |
 |  is_prerelease
 |      Whether this version is a pre-release.
 |
 |      >>> Version("1.2.3").is_prerelease
 |      False
 |      >>> Version("1.2.3a1").is_prerelease
 |      True
 |      >>> Version("1.2.3b1").is_prerelease
 |      True
 |      >>> Version("1.2.3rc1").is_prerelease
 |      True
 |      >>> Version("1.2.3dev1").is_prerelease
 |      True
 |
 |  local
 |      The local version segment of the version.
 |
 |      >>> print(Version("1.2.3").local)
 |      None
 |      >>> Version("1.2.3+abc").local
 |      'abc'
 |
 |  major
 |      The first item of :attr:`release` or ``0`` if unavailable.
 |
 |      >>> Version("1.2.3").major
 |      1
 |
 |  micro
 |      The third item of :attr:`release` or ``0`` if unavailable.
 |
 |      >>> Version("1.2.3").micro
 |      3
 |      >>> Version("1").micro
 |      0
 |
 |  minor
 |      The second item of :attr:`release` or ``0`` if unavailable.
 |
 |      >>> Version("1.2.3").minor
 |      2
 |      >>> Version("1").minor
 |      0
 |
 |  post
 |      The post-release number of the version.
 |
 |      >>> print(Version("1.2.3").post)
 |      None
 |      >>> Version("1.2.3.post1").post
 |      1
 |
 |  pre
 |      The pre-release segment of the version.
 |
 |      >>> print(Version("1.2.3").pre)
 |      None
 |      >>> Version("1.2.3a1").pre
 |      ('a', 1)
 |      >>> Version("1.2.3b1").pre
 |      ('b', 1)
 |      >>> Version("1.2.3rc1").pre
 |      ('rc', 1)
 |
 |  public
 |      The public portion of the version.
 |
 |      >>> Version("1.2.3").public
 |      '1.2.3'
 |      >>> Version("1.2.3+abc").public
 |      '1.2.3'
 |      >>> Version("1.2.3+abc.dev1").public
 |      '1.2.3'
 |
 |  release
 |      The components of the "release" segment of the version.
 |
 |      >>> Version("1.2.3").release
 |      (1, 2, 3)
 |      >>> Version("2.0.0").release
 |      (2, 0, 0)
 |      >>> Version("1!2.0.0.post0").release
 |      (2, 0, 0)
 |
 |      Includes trailing zeroes but not the epoch or any pre-release / development /
 |      post-release suffixes.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'_key': 'CmpKey'}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseVersion:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: '_BaseVersion') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: '_BaseVersion') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __le__(self, other: '_BaseVersion') -> 'bool'
 |      Return self<=value.
 |
 |  __lt__(self, other: '_BaseVersion') -> 'bool'
 |      Return self<value.
 |
 |  __ne__(self, other: 'object') -> 'bool'
 |      Return self!=value.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseVersion:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class VisitedTable in module faiss.swigfaiss

class VisitedTable(builtins.object)
 |  VisitedTable(*args, **kwargs)
 |
 |  Abstract base class for a fast, reusable Visited Set for graph search
 |  algorithms.
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  advance(self)
 |      reset all flags to false
 |
 |  get(self, no)
 |      get flag #no
 |
 |  prefetch(self, no)
 |      prefetch flag #no
 |
 |  reserve(self, arg2)
 |      pre-allocate bucket space to avoid rehashing during repeated set() calls
 |
 |  set(self, no)
 |      set flag #no to true, return whether this changed it.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VisitedTable(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  thisown
 |      The membership flag

Python Library Documentation: class VisitedTableSet in module faiss.swigfaiss

class VisitedTableSet(VisitedTable)
 |  Set-based implementation using unordered_set.
 |  O(1) to construct and O(visits) to advance.
 |
 |  Method resolution order:
 |      VisitedTableSet
 |      VisitedTable
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  advance(self)
 |      reset all flags to false
 |
 |  get(self, no)
 |      get flag #no
 |
 |  prefetch(self, arg2)
 |      prefetch flag #no
 |
 |  reserve(self, n)
 |      pre-allocate bucket space to avoid rehashing during repeated set() calls
 |
 |  set(self, no)
 |      set flag #no to true, return whether this changed it.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VisitedTableSet(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  visited_set
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VisitedTable:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class VisitedTableVector in module faiss.swigfaiss

class VisitedTableVector(VisitedTable)
 |  VisitedTableVector(size)
 |
 |  Vector-based implementation using a versioned byte array.
 |  Faster for get()/set(), but O(size) to initialize.
 |  advance() is O(1) except every 250 calls, which are O(size).
 |
 |  Method resolution order:
 |      VisitedTableVector
 |      VisitedTable
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  advance(self)
 |      reset all flags to false
 |
 |  get(self, no)
 |      get flag #no
 |
 |  prefetch(self, no)
 |      prefetch flag #no
 |
 |  set(self, no)
 |      set flag #no to true, return whether this changed it.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_VisitedTableVector(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  visited
 |
 |  visno
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from VisitedTable:
 |
 |  reserve(self, arg2)
 |      pre-allocate bucket space to avoid rehashing during repeated set() calls
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from VisitedTable:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: SwigPyObject in module swig_runtime_data5 object

class SwigPyObject(builtins.object)
 |  Swig object holding a C/C++ pointer
 |
 |  Methods defined here:
 |
 |  __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.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  acquire(...)
 |      acquires ownership of the pointer
 |
 |  append(...)
 |      appends another 'this' object
 |
 |  disown(...)
 |      releases ownership of the pointer
 |
 |  next(...)
 |      returns the next 'this' object
 |
 |  own(...)
 |      returns/sets ownership of the pointer
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Python Library Documentation: class ZeroCopyIOReader in module faiss.swigfaiss

class ZeroCopyIOReader(IOReader)
 |  ZeroCopyIOReader(data, size)
 |
 |  Method resolution order:
 |      ZeroCopyIOReader
 |      IOReader
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, ptr, size, nitems)
 |      Call self as a function.
 |
 |  __init__(self, data, size)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  filedescriptor(self)
 |
 |  get_data_view(self, ptr, size, nitems)
 |
 |  reset(self)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ZeroCopyIOReader(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  data_
 |
 |  rp_
 |
 |  thisown
 |      The membership flag
 |
 |  total_
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from IOReader:
 |
 |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IOReader:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  name

Python Library Documentation: class ZnSphereCodec in module faiss.swigfaiss

class ZnSphereCodec(ZnSphereSearch, EnumeratedVectors)
 |  ZnSphereCodec(dim_in, r2_in)
 |
 |   codec that can return ids for the encoded vectors
 |
 |  uses the ZnSphereSearch to encode the vector by encoding the
 |  permutation and signs. Depends on ZnSphereSearch because it uses
 |  the atom numbers
 |
 |  Method resolution order:
 |      ZnSphereCodec
 |      ZnSphereSearch
 |      EnumeratedVectors
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, dim_in, r2_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, code, c)
 |      decode it
 |
 |  encode(self, x)
 |      takes vectors that do not need to be centroids
 |
 |  search_and_encode(self, x)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ZnSphereCodec(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  code_segments
 |
 |  code_size
 |
 |  nv
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ZnSphereSearch:
 |
 |  search(self, *args)
 |      *Overload 1:*
 |      find nearest centroid. x does not need to be normalized
 |
 |      |
 |
 |      *Overload 2:*
 |      full call. Requires externally-allocated temp space
 |
 |      |
 |
 |      *Overload 3:*
 |      full call. Requires externally-allocated temp space
 |
 |  search_multi(self, n, x, c_out, dp_out)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ZnSphereSearch:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dimS
 |
 |  natom
 |
 |  r2
 |
 |  voc
 |      size dim * natom
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from EnumeratedVectors:
 |
 |  decode_multi(self, nc, codes, c)
 |
 |  encode_multi(self, nc, c, codes)
 |
 |  find_nn(self, n, codes, nq, xq, idx, dis)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from EnumeratedVectors:
 |
 |  dim

Python Library Documentation: class ZnSphereCodecAlt in module faiss.swigfaiss

class ZnSphereCodecAlt(ZnSphereCodec)
 |  ZnSphereCodecAlt(dim_in, r2_in)
 |
 |   Codec that uses the recursive codec if dim is a power of 2 and
 |  the regular one otherwise
 |
 |  Method resolution order:
 |      ZnSphereCodecAlt
 |      ZnSphereCodec
 |      ZnSphereSearch
 |      EnumeratedVectors
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, dim_in, r2_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, code, c)
 |      decode it
 |
 |  encode(self, x)
 |      takes vectors that do not need to be centroids
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ZnSphereCodecAlt(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  thisown
 |      The membership flag
 |
 |  use_rec
 |
 |  znc_rec
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ZnSphereCodec:
 |
 |  search_and_encode(self, x)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ZnSphereCodec:
 |
 |  code_segments
 |
 |  code_size
 |
 |  nv
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ZnSphereSearch:
 |
 |  search(self, *args)
 |      *Overload 1:*
 |      find nearest centroid. x does not need to be normalized
 |
 |      |
 |
 |      *Overload 2:*
 |      full call. Requires externally-allocated temp space
 |
 |      |
 |
 |      *Overload 3:*
 |      full call. Requires externally-allocated temp space
 |
 |  search_multi(self, n, x, c_out, dp_out)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ZnSphereSearch:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dimS
 |
 |  natom
 |
 |  r2
 |
 |  voc
 |      size dim * natom
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from EnumeratedVectors:
 |
 |  decode_multi(self, nc, codes, c)
 |
 |  encode_multi(self, nc, c, codes)
 |
 |  find_nn(self, n, codes, nq, xq, idx, dis)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from EnumeratedVectors:
 |
 |  dim

Python Library Documentation: class ZnSphereCodecRec in module faiss.swigfaiss

class ZnSphereCodecRec(EnumeratedVectors)
 |  ZnSphereCodecRec(dim_in, r2_in)
 |
 |   recursive sphere codec
 |
 |  Uses a recursive decomposition on the dimensions to encode
 |  centroids found by the ZnSphereSearch. The codes are *not*
 |  compatible with the ones of ZnSphereCodec
 |
 |  Method resolution order:
 |      ZnSphereCodecRec
 |      EnumeratedVectors
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, dim_in, r2_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  decode(self, code, c)
 |      decode it
 |
 |  encode(self, x)
 |      vectors need to be centroids (does not work on arbitrary
 |      vectors)
 |
 |  encode_centroid(self, c)
 |
 |  get_nv(self, ld, r2a)
 |
 |  get_nv_cum(self, ld, r2t, r2a)
 |
 |  set_nv_cum(self, ld, r2t, r2a, v)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ZnSphereCodecRec(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  all_nv
 |
 |  all_nv_cum
 |
 |  code_size
 |
 |  decode_cache
 |
 |  decode_cache_ld
 |
 |  log2_dim
 |
 |  r2
 |
 |  thisown
 |      The membership flag
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from EnumeratedVectors:
 |
 |  decode_multi(self, nc, codes, c)
 |
 |  encode_multi(self, nc, c, codes)
 |
 |  find_nn(self, n, codes, nq, xq, idx, dis)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from EnumeratedVectors:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dim
 |
 |  nv
 |      size of the collection

Python Library Documentation: class ZnSphereSearch in module faiss.swigfaiss

class ZnSphereSearch(builtins.object)
 |  ZnSphereSearch(dim, r2_in)
 |
 |   returns the nearest vertex in the sphere to a query. Returns only
 |  the coordinates, not an id.
 |
 |  Algorithm: all points are derived from a one atom vector up to a
 |  permutation and sign changes. The search function finds the most
 |  appropriate atom and transformation.
 |
 |  Methods defined here:
 |
 |  __init__(self, dim, r2_in)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  search(self, *args)
 |      *Overload 1:*
 |      find nearest centroid. x does not need to be normalized
 |
 |      |
 |
 |      *Overload 2:*
 |      full call. Requires externally-allocated temp space
 |
 |      |
 |
 |      *Overload 3:*
 |      full call. Requires externally-allocated temp space
 |
 |  search_multi(self, n, x, c_out, dp_out)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_ZnSphereSearch(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  dimS
 |
 |  natom
 |
 |  r2
 |
 |  thisown
 |      The membership flag
 |
 |  voc
 |      size dim * natom

Python Library Documentation: function add_ref_in_constructor in module faiss

add_ref_in_constructor(the_class, parameter_no)

Python Library Documentation: function add_ref_in_function in module faiss

add_ref_in_function(function_name, parameter_no)

Python Library Documentation: function add_ref_in_method in module faiss

add_ref_in_method(the_class, method_name, parameter_no)

Python Library Documentation: function add_ref_in_method_explicit_own in module faiss

add_ref_in_method_explicit_own(the_class, method_name)

Python Library Documentation: function add_to_referenced_objects in module faiss

add_to_referenced_objects(self, ref)

Python Library Documentation: function approx_topk_by_mode in module faiss.swigfaiss

approx_topk_by_mode(mode, beam_size, n_per_beam, distances, k, bh_val, bh_ids)

Python Library Documentation: function aq_estimate_norm_scale in module faiss.swigfaiss

aq_estimate_norm_scale(M, ksub, M_norm, LUT)

Python Library Documentation: function aq_quantize_LUT_and_bias in module faiss.swigfaiss

aq_quantize_LUT_and_bias(nprobe, M, ksub, LUT, bias, M_norm, norm_scale, LUTq, M2, biasq, a_out, b_out)

Python Library Documentation: built-in module array

NAME
    array

DESCRIPTION
    This module defines an object type which can efficiently represent
    an array of basic values: characters, integers, floating-point
    numbers.  Arrays are sequence types and behave very much like lists,
    except that the type of objects stored in them is constrained.

CLASSES
    builtins.object
        array

    ArrayType = class array(builtins.object)
     |  array(typecode [, initializer]) -> array
     |
     |  Return a new array whose items are restricted by typecode, and
     |  initialized from the optional initializer value, which must be a list,
     |  string or iterable over elements of the appropriate type.
     |
     |  Arrays represent basic values and behave very much like lists, except
     |  the type of objects stored in them is constrained. The type is specified
     |  at object creation time by using a type code, which is a single character.
     |  The following type codes are defined:
     |
     |      Type code   C Type             Minimum size in bytes
     |      'b'         signed integer     1
     |      'B'         unsigned integer   1
     |      'u'         Unicode character  2 (see note)
     |      'h'         signed integer     2
     |      'H'         unsigned integer   2
     |      'i'         signed integer     2
     |      'I'         unsigned integer   2
     |      'l'         signed integer     4
     |      'L'         unsigned integer   4
     |      'q'         signed integer     8 (see note)
     |      'Q'         unsigned integer   8 (see note)
     |      'f'         floating-point     4
     |      'd'         floating-point     8
     |
     |  NOTE: The 'u' typecode corresponds to Python's unicode character. On
     |  narrow builds this is 2-bytes on wide builds this is 4-bytes.
     |
     |  NOTE: The 'q' and 'Q' type codes are only available if the platform
     |  C compiler used to build Python supports 'long long', or, on Windows,
     |  '__int64'.
     |
     |  Methods:
     |
     |  append() -- append a new item to the end of the array
     |  buffer_info() -- return information giving the current memory info
     |  byteswap() -- byteswap all the items of the array
     |  count() -- return number of occurrences of an object
     |  extend() -- extend array by appending multiple elements from an iterable
     |  fromfile() -- read items from a file object
     |  fromlist() -- append items from the list
     |  frombytes() -- append items from the string
     |  index() -- return index of first occurrence of an object
     |  insert() -- insert a new item into the array at a provided position
     |  pop() -- remove and return item (default last)
     |  remove() -- remove first occurrence of an object
     |  reverse() -- reverse the order of the items in the array
     |  tofile() -- write all items to a file object
     |  tolist() -- return the array converted to an ordinary list
     |  tobytes() -- return the array converted to a string
     |
     |  Attributes:
     |
     |  typecode -- the typecode character used to create the array
     |  itemsize -- the length in bytes of one array item
     |
     |  Methods defined here:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __contains__(self, key, /)
     |      Return bool(key in self).
     |
     |  __copy__(self, /)
     |      Return a copy of the array.
     |
     |  __deepcopy__(self, unused, /)
     |      Return a copy of the array.
     |
     |  __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.
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __reduce_ex__(self, value, /)
     |      Return state information for pickling.
     |
     |  __release_buffer__(self, buffer, /)
     |      Release the buffer object that exposes the underlying memory of the object.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  __sizeof__(self, /)
     |      Size of the array in memory, in bytes.
     |
     |  append(self, v, /)
     |      Append new value v to the end of the array.
     |
     |  buffer_info(self, /)
     |      Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.
     |
     |      The length should be multiplied by the itemsize attribute to calculate
     |      the buffer length in bytes.
     |
     |  byteswap(self, /)
     |      Byteswap all items of the array.
     |
     |      If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is
     |      raised.
     |
     |  count(self, v, /)
     |      Return number of occurrences of v in the array.
     |
     |  extend(self, bb, /)
     |      Append items to the end of the array.
     |
     |  frombytes(self, buffer, /)
     |      Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method.
     |
     |  fromfile(self, f, n, /)
     |      Read n objects from the file object f and append them to the end of the array.
     |
     |  fromlist(self, list, /)
     |      Append items to array from list.
     |
     |  fromunicode(self, ustr, /)
     |      Extends this array with data from the unicode string ustr.
     |
     |      The array must be a unicode type array; otherwise a ValueError is raised.
     |      Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of
     |      some other type.
     |
     |  index(self, v, start=0, stop=9223372036854775807, /)
     |      Return index of first occurrence of v in the array.
     |
     |      Raise ValueError if the value is not present.
     |
     |  insert(self, i, v, /)
     |      Insert a new item v into the array before position i.
     |
     |  pop(self, i=-1, /)
     |      Return the i-th element and delete it from the array.
     |
     |      i defaults to -1.
     |
     |  remove(self, v, /)
     |      Remove the first occurrence of v in the array.
     |
     |  reverse(self, /)
     |      Reverse the order of the items in the array.
     |
     |  tobytes(self, /)
     |      Convert the array to an array of machine values and return the bytes representation.
     |
     |  tofile(self, f, /)
     |      Write all items (as machine values) to the file object f.
     |
     |  tolist(self, /)
     |      Convert array to an ordinary list with the same items.
     |
     |  tounicode(self, /)
     |      Extends this array with data from the unicode string ustr.
     |
     |      Convert the array to a unicode string.  The array must be a unicode type array;
     |      otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a
     |      unicode string from an array of some other type.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      See PEP 585
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  itemsize
     |      the size, in bytes, of one array item
     |
     |  typecode
     |      the typecode character used to create the array
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

    class array(builtins.object)
     |  array(typecode [, initializer]) -> array
     |
     |  Return a new array whose items are restricted by typecode, and
     |  initialized from the optional initializer value, which must be a list,
     |  string or iterable over elements of the appropriate type.
     |
     |  Arrays represent basic values and behave very much like lists, except
     |  the type of objects stored in them is constrained. The type is specified
     |  at object creation time by using a type code, which is a single character.
     |  The following type codes are defined:
     |
     |      Type code   C Type             Minimum size in bytes
     |      'b'         signed integer     1
     |      'B'         unsigned integer   1
     |      'u'         Unicode character  2 (see note)
     |      'h'         signed integer     2
     |      'H'         unsigned integer   2
     |      'i'         signed integer     2
     |      'I'         unsigned integer   2
     |      'l'         signed integer     4
     |      'L'         unsigned integer   4
     |      'q'         signed integer     8 (see note)
     |      'Q'         unsigned integer   8 (see note)
     |      'f'         floating-point     4
     |      'd'         floating-point     8
     |
     |  NOTE: The 'u' typecode corresponds to Python's unicode character. On
     |  narrow builds this is 2-bytes on wide builds this is 4-bytes.
     |
     |  NOTE: The 'q' and 'Q' type codes are only available if the platform
     |  C compiler used to build Python supports 'long long', or, on Windows,
     |  '__int64'.
     |
     |  Methods:
     |
     |  append() -- append a new item to the end of the array
     |  buffer_info() -- return information giving the current memory info
     |  byteswap() -- byteswap all the items of the array
     |  count() -- return number of occurrences of an object
     |  extend() -- extend array by appending multiple elements from an iterable
     |  fromfile() -- read items from a file object
     |  fromlist() -- append items from the list
     |  frombytes() -- append items from the string
     |  index() -- return index of first occurrence of an object
     |  insert() -- insert a new item into the array at a provided position
     |  pop() -- remove and return item (default last)
     |  remove() -- remove first occurrence of an object
     |  reverse() -- reverse the order of the items in the array
     |  tofile() -- write all items to a file object
     |  tolist() -- return the array converted to an ordinary list
     |  tobytes() -- return the array converted to a string
     |
     |  Attributes:
     |
     |  typecode -- the typecode character used to create the array
     |  itemsize -- the length in bytes of one array item
     |
     |  Methods defined here:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __contains__(self, key, /)
     |      Return bool(key in self).
     |
     |  __copy__(self, /)
     |      Return a copy of the array.
     |
     |  __deepcopy__(self, unused, /)
     |      Return a copy of the array.
     |
     |  __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.
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __reduce_ex__(self, value, /)
     |      Return state information for pickling.
     |
     |  __release_buffer__(self, buffer, /)
     |      Release the buffer object that exposes the underlying memory of the object.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  __sizeof__(self, /)
     |      Size of the array in memory, in bytes.
     |
     |  append(self, v, /)
     |      Append new value v to the end of the array.
     |
     |  buffer_info(self, /)
     |      Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.
     |
     |      The length should be multiplied by the itemsize attribute to calculate
     |      the buffer length in bytes.
     |
     |  byteswap(self, /)
     |      Byteswap all items of the array.
     |
     |      If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is
     |      raised.
     |
     |  count(self, v, /)
     |      Return number of occurrences of v in the array.
     |
     |  extend(self, bb, /)
     |      Append items to the end of the array.
     |
     |  frombytes(self, buffer, /)
     |      Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method.
     |
     |  fromfile(self, f, n, /)
     |      Read n objects from the file object f and append them to the end of the array.
     |
     |  fromlist(self, list, /)
     |      Append items to array from list.
     |
     |  fromunicode(self, ustr, /)
     |      Extends this array with data from the unicode string ustr.
     |
     |      The array must be a unicode type array; otherwise a ValueError is raised.
     |      Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of
     |      some other type.
     |
     |  index(self, v, start=0, stop=9223372036854775807, /)
     |      Return index of first occurrence of v in the array.
     |
     |      Raise ValueError if the value is not present.
     |
     |  insert(self, i, v, /)
     |      Insert a new item v into the array before position i.
     |
     |  pop(self, i=-1, /)
     |      Return the i-th element and delete it from the array.
     |
     |      i defaults to -1.
     |
     |  remove(self, v, /)
     |      Remove the first occurrence of v in the array.
     |
     |  reverse(self, /)
     |      Reverse the order of the items in the array.
     |
     |  tobytes(self, /)
     |      Convert the array to an array of machine values and return the bytes representation.
     |
     |  tofile(self, f, /)
     |      Write all items (as machine values) to the file object f.
     |
     |  tolist(self, /)
     |      Convert array to an ordinary list with the same items.
     |
     |  tounicode(self, /)
     |      Extends this array with data from the unicode string ustr.
     |
     |      Convert the array to a unicode string.  The array must be a unicode type array;
     |      otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a
     |      unicode string from an array of some other type.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      See PEP 585
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  itemsize
     |      the size, in bytes, of one array item
     |
     |  typecode
     |      the typecode character used to create the array
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

DATA
    typecodes = 'bBuhHiIlLqQfd'

FILE
    (built-in)

Python Library Documentation: module faiss.array_conversions in faiss

NAME
    faiss.array_conversions

DESCRIPTION
    # Copyright (c) Facebook, Inc. and its affiliates.
    #
    # This source code is licensed under the MIT license found in the
    # LICENSE file in the root directory of this source tree.

CLASSES
    faiss.swigfaiss.Float32Vector(builtins.object)
        FloatVector
    faiss.swigfaiss.Float32VectorVector(builtins.object)
        FloatVectorVector
    faiss.swigfaiss.Float64Vector(builtins.object)
        DoubleVector
    faiss.swigfaiss.Int32Vector(builtins.object)
        IntVector
        LongVector
    faiss.swigfaiss.Int32VectorVector(builtins.object)
        LongVectorVector
    faiss.swigfaiss.Int64Vector(builtins.object)
        LongLongVector
    faiss.swigfaiss.Int8Vector(builtins.object)
        CharVector
    faiss.swigfaiss.UInt64Vector(builtins.object)
        Uint64Vector
    faiss.swigfaiss.UInt8Vector(builtins.object)
        ByteVector
    faiss.swigfaiss.UInt8VectorVector(builtins.object)
        ByteVectorVector

    class ByteVector(faiss.swigfaiss.UInt8Vector)
     |  ByteVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      ByteVector
     |      faiss.swigfaiss.UInt8Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.UInt8Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.UInt8Vector:
     |
     |  __swig_destroy__ = delete_UInt8Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.UInt8Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class ByteVectorVector(faiss.swigfaiss.UInt8VectorVector)
     |  ByteVectorVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      ByteVectorVector
     |      faiss.swigfaiss.UInt8VectorVector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.UInt8VectorVector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.UInt8VectorVector:
     |
     |  __swig_destroy__ = delete_UInt8VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.UInt8VectorVector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class CharVector(faiss.swigfaiss.Int8Vector)
     |  CharVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      CharVector
     |      faiss.swigfaiss.Int8Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Int8Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Int8Vector:
     |
     |  __swig_destroy__ = delete_Int8Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Int8Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class DoubleVector(faiss.swigfaiss.Float64Vector)
     |  DoubleVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      DoubleVector
     |      faiss.swigfaiss.Float64Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Float64Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Float64Vector:
     |
     |  __swig_destroy__ = delete_Float64Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Float64Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class FloatVector(faiss.swigfaiss.Float32Vector)
     |  FloatVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      FloatVector
     |      faiss.swigfaiss.Float32Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Float32Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Float32Vector:
     |
     |  __swig_destroy__ = delete_Float32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Float32Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class FloatVectorVector(faiss.swigfaiss.Float32VectorVector)
     |  FloatVectorVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      FloatVectorVector
     |      faiss.swigfaiss.Float32VectorVector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Float32VectorVector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Float32VectorVector:
     |
     |  __swig_destroy__ = delete_Float32VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Float32VectorVector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class IntVector(faiss.swigfaiss.Int32Vector)
     |  IntVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      IntVector
     |      faiss.swigfaiss.Int32Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Int32Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Int32Vector:
     |
     |  __swig_destroy__ = delete_Int32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Int32Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class LongLongVector(faiss.swigfaiss.Int64Vector)
     |  LongLongVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      LongLongVector
     |      faiss.swigfaiss.Int64Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Int64Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Int64Vector:
     |
     |  __swig_destroy__ = delete_Int64Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Int64Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class LongVector(faiss.swigfaiss.Int32Vector)
     |  LongVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      LongVector
     |      faiss.swigfaiss.Int32Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Int32Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Int32Vector:
     |
     |  __swig_destroy__ = delete_Int32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Int32Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class LongVectorVector(faiss.swigfaiss.Int32VectorVector)
     |  LongVectorVector(*args, **kwargs)
     |
     |  Method resolution order:
     |      LongVectorVector
     |      faiss.swigfaiss.Int32VectorVector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.Int32VectorVector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.Int32VectorVector:
     |
     |  __swig_destroy__ = delete_Int32VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.Int32VectorVector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Uint64Vector(faiss.swigfaiss.UInt64Vector)
     |  Uint64Vector(*args, **kwargs)
     |
     |  Method resolution order:
     |      Uint64Vector
     |      faiss.swigfaiss.UInt64Vector
     |      builtins.object
     |
     |  Static methods defined here:
     |
     |  __new__ = new_meth(cls, *args, **kwargs) from _make_deprecated_swig_class.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from faiss.swigfaiss.UInt64Vector:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self) from faiss.swigfaiss
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from faiss.swigfaiss.UInt64Vector:
     |
     |  __swig_destroy__ = delete_UInt64Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from faiss.swigfaiss.UInt64Vector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

FUNCTIONS
    AlignedTable_to_array(v)
        convert an AlignedTable to a numpy array

    array_to_AlignedTable(a)

    copy_array_to_AlignedTable(a, v)

    copy_array_to_vector(a, v)
        copy a numpy array to a vector

    vector_float_to_array(v)

    vector_to_array(v)
        convert a C++ vector to a numpy array

DATA
    APPROX_TOPK_BUCKETS_B16_D2 = 3
    APPROX_TOPK_BUCKETS_B32_D2 = 1
    APPROX_TOPK_BUCKETS_B8_D2 = 4
    APPROX_TOPK_BUCKETS_B8_D3 = 2
    ClusteringInitMethod_AFK_MC2 = 2
    ClusteringInitMethod_KMEANS_PLUS_PLUS = 1
    ClusteringInitMethod_RANDOM = 0
    EXACT_TOPK = 0
    FAISS_VERSION_MAJOR = 1
    FAISS_VERSION_MINOR = 14
    FAISS_VERSION_PATCH = 3
    Float16 = 1
    Float32 = 0
    IO_FLAG_MMAP = 1684996104
    IO_FLAG_MMAP_IFC = 512
    IO_FLAG_ONDISK_SAME_DIR = 4
    IO_FLAG_PQ_SKIP_SDC_TABLE = 32
    IO_FLAG_READ_ONLY = 2
    IO_FLAG_SKIP_IVF_DATA = 8
    IO_FLAG_SKIP_PRECOMPUTE_TABLE = 16
    IO_FLAG_SKIP_STORAGE = 1
    Int8 = 3
    METRIC_BrayCurtis = 21
    METRIC_Canberra = 20
    METRIC_GOWER = 25
    METRIC_INNER_PRODUCT = 0
    METRIC_Jaccard = 23
    METRIC_JensenShannon = 22
    METRIC_L1 = 2
    METRIC_L2 = 1
    METRIC_Linf = 3
    METRIC_Lp = 4
    METRIC_NaNEuclidean = 24
    SHARED_PTR_DISOWN = 0
    SIMDLevel_ARM_NEON = 4
    SIMDLevel_ARM_SVE = 5
    SIMDLevel_AVX2 = 1
    SIMDLevel_AVX512 = 2
    SIMDLevel_AVX512_SPR = 3
    SIMDLevel_COUNT = 7
    SIMDLevel_NONE = 0
    SIMDLevel_RISCV_RVV = 6
    SINGLE_SIMD_LEVEL = 0
    SINGLE_SIMD_LEVEL_256 = 0
    SINGLE_SIMD_LEVEL_512 = 0
    UInt8 = 2
    VERSION_STRING = '1.14.3'
    Z_MAX_BY_QB = <Swig Object of type 'float *'>
    base_prefix = 'UInt64'
    cvar = <Swig global variables>
    depr_prefix = 'Uint64'
    deprecated_name_map = {'Byte': 'UInt8', 'Char': 'Int8', 'Double': 'Flo...
    hamdis_tab_ham_bytes = <Swig Object of type 'unsigned char *'>
    has_AVX2 = True
    has_AVX512 = False
    has_AVX512_SPR = False
    has_SVE = False
    instruction_sets = {'AVX', 'AVX2', 'F16C', 'FMA3', 'MMX', 'POPCNT', .....
    loaded = False
    logger = <Logger faiss.loader (WARNING)>
    opt_env_variable_name = 'FAISS_OPT_LEVEL'
    opt_level = None
    sizeof_long = 4
    vector_name_map = {'Byte': 'uint8', 'Char': 'int8', 'Double': 'float64...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\array_conversions.py

Python Library Documentation: function array_to_AlignedTable in module faiss.array_conversions

array_to_AlignedTable(a)

Error rendering doc: No Python documentation found for 'UInt64'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

Python Library Documentation: function beam_search_encode_step in module faiss.swigfaiss

beam_search_encode_step(*args)
     Encode a residual by sampling from a centroid table.

    This is a single encoding step the residual quantizer.
    It allows low-level access to the encoding function, exposed mainly for unit
    tests.

    :type n: int
    :param n:              number of vectors to handle
    :type residuals: float
    :param residuals:      vectors to encode, size (n, beam_size, d)
    :type cent: float
    :param cent:           centroids, size (K, d)
    :type beam_size: int
    :param beam_size:      input beam size
    :type m: int
    :param m:              size of the codes for the previous encoding steps
    :type codes: int
    :param codes:          code array for the previous steps of the beam (n,
        beam_size, m)
    :type new_beam_size: int
    :param new_beam_size:  output beam size (should be <= K * beam_size)
    :type new_codes: int
    :param new_codes:      output codes, size (n, new_beam_size, m + 1)
    :type new_residuals: float
    :param new_residuals:  output residuals, size (n, new_beam_size, d)
    :type new_distances: float
    :param new_distances:  output distances, size (n, new_beam_size)
    :type assign_index: :py:class:`Index`, optional
    :param assign_index:   if non-NULL, will be used to perform assignment

Python Library Documentation: function beam_search_encode_step_tab in module faiss.swigfaiss

beam_search_encode_step_tab(*args)
     Encode a set of vectors using their dot products with the codebooks

    :type K: int
    :param K:           number of vectors in the codebook
    :type n: int
    :param n:           nb of vectors to encode
    :type beam_size: int
    :param beam_size:   input beam size
    :type codebook_cross_norms: float
    :param codebook_cross_norms: inner product of this codebook with the m
                                    previously encoded codebooks
    :type codebook_offsets: int
    :param codebook_offsets:     offsets into codebook_cross_norms for each
                                    previous codebook
    :type query_cp: float
    :param query_cp:    dot products of query vectors with ???
    :type cent_norms_i: float
    :param cent_norms_i:  norms of centroids

Python Library Documentation: function binary_to_real in module faiss.swigfaiss

binary_to_real(d, x_in, x_out)
     Convert binary vector to +1/-1 valued float vector.

    :type d: int
    :param d:      dimension of the vector (multiple of 8)
    :type x_in: uint8_t
    :param x_in:   input binary vector (uint8_t table of size d / 8)
    :type x_out: float
    :param x_out:  output float vector (float table of size d)

Python Library Documentation: function bincode_hist in module faiss.swigfaiss

bincode_hist(n, nbits, codes, hist)
     Compute histogram of bits on a code array

    :type codes: uint8_t
    :param codes:   size(n, nbits / 8)
    :type hist: int
    :param hist:    size(nbits): nb of 1s in the array of codes

Python Library Documentation: function bitvec_print in module faiss.swigfaiss

bitvec_print(b, d)

Python Library Documentation: function bitvec_shuffle in module faiss.swigfaiss

bitvec_shuffle(n, da, db, order, a, b)
    Shuffle the bits from b(i, j) := a(i, order[j])

Python Library Documentation: function bitvecs2fvecs in module faiss.swigfaiss

bitvecs2fvecs(b, x, d, n)

Python Library Documentation: function bucket_sort in module faiss.extra_wrappers

bucket_sort(tab, nbucket=None, nt=0)
    Perform a bucket sort on a table of integers.

    Parameters
    ----------
    tab : array_like
        elements to sort, max value nbucket - 1
    nbucket : integer
        number of buckets, None if unknown
    nt : integer
        number of threads to use (0 = use unthreaded codepath)

    Returns
    -------
    lims : array_like
        cumulative sum of bucket sizes (size vmax + 1)
    perm : array_like
        perm[lims[i] : lims[i + 1]] contains the indices of bucket #i (size tab.size)

Python Library Documentation: function bvec_checksum in module faiss.swigfaiss

bvec_checksum(n, a)
    compute a checksum on a table.

Python Library Documentation: function bvecs_checksum in module faiss.swigfaiss

bvecs_checksum(n, d, a, cs)
     compute checksums for the rows of a matrix

    :type n: int
    :param n:   number of rows
    :type d: int
    :param d:   size per row
    :type a: uint8_t
    :param a:   matrix to handle, size n * d
    :type cs: int
    :param cs:  output checksums, size n

Python Library Documentation: function byte_rand in module faiss.swigfaiss

byte_rand(x, n, seed)

Python Library Documentation: function cast_integer_to_float_ptr in module faiss.swigfaiss

cast_integer_to_float_ptr(x)

Python Library Documentation: function cast_integer_to_idx_t_ptr in module faiss.swigfaiss

cast_integer_to_idx_t_ptr(x)

Python Library Documentation: function cast_integer_to_int_ptr in module faiss.swigfaiss

cast_integer_to_int_ptr(x)

Python Library Documentation: function cast_integer_to_uint8_ptr in module faiss.swigfaiss

cast_integer_to_uint8_ptr(x)

Python Library Documentation: function cast_integer_to_void_ptr in module faiss.swigfaiss

cast_integer_to_void_ptr(x)

Python Library Documentation: function check_compatible_for_merge in module faiss.swigfaiss

check_compatible_for_merge(index1, index2)
     check if two indexes have the same parameters and are trained in
    the same way, otherwise throw.

Python Library Documentation: function check_openmp in module faiss.swigfaiss

check_openmp()
    Whether OpenMP annotations were respected.

Python Library Documentation: function checksum in module faiss.extra_wrappers

checksum(a)
    compute a checksum for quick-and-dirty comparisons of arrays

Python Library Documentation: module faiss.class_wrappers in faiss

NAME
    faiss.class_wrappers

DESCRIPTION
    # Copyright (c) Meta Platforms, Inc. and affiliates.
    #
    # This source code is licensed under the MIT license found in the
    # LICENSE file in the root directory of this source tree.

CLASSES
    builtins.object
        RememberSwigOwnership

    class RememberSwigOwnership(builtins.object)
     |  RememberSwigOwnership(obj)
     |
     |  SWIG's seattr transfers ownership of SWIG wrapped objects to the class
     |  (btw this seems to contradict https://www.swig.org/Doc1.3/Python.html#Python_nn22
     |  31.4.2)
     |  This interferes with how we manage ownership: with the referenced_objects
     |  table. Therefore, we reset the thisown field in this context manager.
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, *ignored)
     |
     |  __init__(self, obj)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    add_to_referenced_objects(self, ref)

    handle_AutoTuneCriterion(the_class)

    handle_Clustering(the_class)

    handle_Clustering1D(the_class)

    handle_CodePacker(the_class)

    handle_CodeSet(the_class)

    handle_Embedding(the_class)

    handle_IDSelectorSubset(the_class, class_owns, force_int64=True)

    handle_IOReader(the_class)
        add a read_bytes method

    handle_IOWriter(the_class)
        add a write_bytes method

    handle_Index(the_class)

    handle_IndexBinary(the_class)

    handle_IndexRowwiseMinMax(the_class)

    handle_Linear(the_class)

    handle_MapLong2Long(the_class)

    handle_MatrixStats(the_class)

    handle_NSG(the_class)

    handle_ParameterSpace(the_class)

    handle_QINCo(the_class)

    handle_QINCoStep(the_class)

    handle_Quantizer(the_class)

    handle_SearchParameters(the_class)
        Protect SearchParameters from leaking SWIG-owned sub-objects assigned
        via either kwargs construction (SearchParametersXX(sel=x)) or bare
        attribute assignment (params.sel = x).

    handle_SuperKMeans(the_class)

    handle_Tensor2D(the_class)

    handle_VectorTransform(the_class)

    handle_shard_ivf_index_centroids(func)

    replace_method(the_class, name, replacement, ignore_missing=False)
        Replaces a method in a class with another version. The old method
        is renamed to method_name_c (because presumably it was implemented in C)

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\class_wrappers.py

Python Library Documentation: function clone_Quantizer in module faiss.swigfaiss

clone_Quantizer(quant)

Python Library Documentation: function clone_binary_index in module faiss.swigfaiss

clone_binary_index(index)

Python Library Documentation: function clone_index in module faiss.swigfaiss

clone_index(arg1)

Python Library Documentation: function compute_1bit_adjusted_distance in module faiss.swigfaiss

compute_1bit_adjusted_distance(normalized_distance, db_factors, query_factors, centered, qb, d)
     Compute adjusted 1-bit distance from normalized LUT distance.
    This is the core distance formula shared by all RaBitQ handlers.

    :type normalized_distance: float
    :param normalized_distance:  Distance from SIMD LUT lookup (after
        normalization)
    :type db_factors: :py:class:`SignBitFactors`
    :param db_factors:          Database vector factors (SignBitFactors or
        SignBitFactorsWithError)
    :type query_factors: :py:class:`QueryFactorsData`
    :param query_factors:       Query factors computed during search
    :type centered: boolean
    :param centered:            Whether centered quantization is used
    :type qb: int
    :param qb:                  Number of quantization bits
    :type d: int
    :param d:                   Dimensionality
    :rtype: float
    :return: Adjusted distance value

Python Library Documentation: function compute_PQ_dis_tables_dsub2 in module faiss.swigfaiss

compute_PQ_dis_tables_dsub2(d, ksub, centroids, nx, x, is_inner_product, dis_tables)
    specialized function for PQ2

Python Library Documentation: function compute_codes_add_centroids_mp_lut0 in module faiss.swigfaiss

compute_codes_add_centroids_mp_lut0(rq, x, codes_out, n, centroids, pool)

Python Library Documentation: function compute_codes_add_centroids_mp_lut1 in module faiss.swigfaiss

compute_codes_add_centroids_mp_lut1(rq, x, codes_out, n, centroids, pool)

Python Library Documentation: function compute_factors_from_intermediates in module faiss.swigfaiss

compute_factors_from_intermediates(norm_L2sqr, or_L2sqr, dp_oO, d, metric_type, compute_error=True)
     Compute final factors from intermediate values.
    :type norm_L2sqr: float
    :param norm_L2sqr:    ||or - c||^2
    :type or_L2sqr: float
    :param or_L2sqr:      ||or||^2
    :type dp_oO: float
    :param dp_oO:         sum of |or_i - c_i|
    :type d: int
    :param d:             dimensionality
    :type metric_type: int
    :param metric_type:   distance metric
    :type compute_error: boolean, optional
    :param compute_error: whether to compute f_error (false for 1-bit mode)
    :rtype: :py:class:`SignBitFactorsWithError`
    :return: computed factors

Python Library Documentation: function compute_full_multibit_distance in module faiss.swigfaiss

compute_full_multibit_distance(sign_bits, ex_code, ex_fac, rotated_q, qr_base, d, ex_bits, metric_type)
     Compute full multi-bit distance from sign bits and ex-bit codes.
    This is the core distance computation shared by RaBitQFastScan handlers.

    The multi-bit distance combines the sign bit (1-bit) with additional
    magnitude bits (ex_bits) to compute a more accurate distance estimate.
    Uses SIMD-optimized bit-plane decomposition (AVX2+BMI2) for ex_bits 1-7,
    with scalar fallback for non-x86 or non-BMI2 platforms.

    :type sign_bits: uint8_t
    :param sign_bits:       unpacked sign bits (1-bit codes in standard format)
    :type ex_code: uint8_t
    :param ex_code:         packed ex-bit codes
    :type ex_fac: :py:class:`ExtraBitsFactors`
    :param ex_fac:          ex-bit factors (f_add_ex, f_rescale_ex)
    :type rotated_q: float
    :param rotated_q:       rotated query vector
    :type qr_base: float
    :param qr_base:         precomputed base term: ||q-c||^2 for L2, <q,c> for IP
    :type d: int
    :param d:               dimensionality
    :type ex_bits: int
    :param ex_bits:         number of extra bits (nb_bits - 1)
    :type metric_type: int
    :param metric_type:     distance metric (L2 or Inner Product)
    :rtype: float
    :return: computed full multi-bit distance

Python Library Documentation: function compute_per_vector_storage_size in module faiss.swigfaiss

compute_per_vector_storage_size(nb_bits, d)
     Compute per-vector auxiliary storage size.

    :type nb_bits: int
    :param nb_bits:  number of quantization bits (1 = sign-bit only)
    :type d: int
    :param d:        dimensionality
    :rtype: int
    :return: storage size in bytes

Python Library Documentation: function compute_query_factors in module faiss.swigfaiss

compute_query_factors(query, d, centroid, qb, centered, metric_type, rotated_q, rotated_qq)
     Compute query factors for RaBitQ distance computation.
    This consolidates the query processing logic shared between implementations.

    :type query: float
    :param query:         query vector (d dimensions)
    :type d: int
    :param d:             dimensionality
    :type centroid: float
    :param centroid:      database centroid (nullptr if not used)
    :type qb: uint8_t
    :param qb:            number of quantization bits (1-8)
    :type centered: boolean
    :param centered:      whether to use centered quantization
    :type metric_type: int
    :param metric_type:   distance metric
    :type rotated_q: std::vector< float >
    :param rotated_q:     output: query - centroid
    :type rotated_qq: std::vector< uint8_t >
    :param rotated_qq:    output: quantized query values
    :rtype: :py:class:`QueryFactorsData`
    :return: computed query factors

Python Library Documentation: function compute_vector_factors in module faiss.swigfaiss

compute_vector_factors(x, d, centroid, metric_type, compute_error=True)
     Compute factors for a single database vector using RaBitQ algorithm.
    This function consolidates the mathematical logic that was duplicated
    between IndexRaBitQ and IndexRaBitQFastScan.

    :type x: float
    :param x:             input vector (d dimensions)
    :type d: int
    :param d:             dimensionality
    :type centroid: float
    :param centroid:      database centroid (nullptr if not used)
    :type metric_type: int
    :param metric_type:   distance metric (L2 or Inner Product)
    :type compute_error: boolean, optional
    :param compute_error: whether to compute f_error (false for 1-bit mode)
    :rtype: :py:class:`SignBitFactorsWithError`
    :return: computed factors for distance computation

Python Library Documentation: function compute_vector_intermediate_values in module faiss.swigfaiss

compute_vector_intermediate_values(x, d, centroid, norm_L2sqr, or_L2sqr, dp_oO)
     Compute intermediate values needed for vector factor computation.
    Separated out to allow different bit packing strategies while sharing
    the core mathematical computation.

    :type x: float
    :param x:             input vector (d dimensions)
    :type d: int
    :param d:             dimensionality
    :type centroid: float
    :param centroid:      database centroid (nullptr if not used)
    :type norm_L2sqr: float
    :param norm_L2sqr:    output: ||or - c||^2
    :type or_L2sqr: float
    :param or_L2sqr:      output: ||or||^2
    :type dp_oO: float
    :param dp_oO:         output: sum of |or_i - c_i| (absolute deviations)

Python Library Documentation: function copy_array_to_AlignedTable in module faiss.array_conversions

copy_array_to_AlignedTable(a, v)

Python Library Documentation: function copy_array_to_vector in module faiss.array_conversions

copy_array_to_vector(a, v)
    copy a numpy array to a vector

Python Library Documentation: function crosshamming_count_thres in module faiss.swigfaiss

crosshamming_count_thres(dbs, n, ht, ncodes, nptr)

Python Library Documentation: SwigVarLink object

class SwigVarLink(builtins.object)
 |  Swig variable link object
 |
 |  Methods defined here:
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __str__(self, /)
 |      Return str(self).

Error rendering doc: No Python documentation found for 'Uint64'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

Python Library Documentation: dict object

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |
 |  Built-in subclasses:
 |      StgDict
 |
 |  Methods defined here:
 |
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, 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__(self, key, /)
 |      Return self[key].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __ior__(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.
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __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
 |
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  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 the key is not found, return the default if given; otherwise,
 |      raise a KeyError.
 |
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  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
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  fromkeys(iterable, value=None, /)
 |      Create a new dictionary with keys from iterable and values set to value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Python Library Documentation: function deserialize_index in module faiss

deserialize_index(data, io_flags=0)

Python Library Documentation: function deserialize_index_binary in module faiss

deserialize_index_binary(data)

Python Library Documentation: function downcast_AdditiveQuantizer in module faiss.swigfaiss

downcast_AdditiveQuantizer(aq)

Python Library Documentation: function downcast_IndexBinary in module faiss.swigfaiss

downcast_IndexBinary(index)

Python Library Documentation: function downcast_InvertedLists in module faiss.swigfaiss

downcast_InvertedLists(il)

Python Library Documentation: function downcast_Quantizer in module faiss.swigfaiss

downcast_Quantizer(aq)

Python Library Documentation: function downcast_VectorTransform in module faiss.swigfaiss

downcast_VectorTransform(vt)

Python Library Documentation: function downcast_index in module faiss.swigfaiss

downcast_index(index)

Python Library Documentation: function eval_intersection in module faiss.extra_wrappers

eval_intersection(I1, I2)
    size of intersection between each line of two result tables

Python Library Documentation: module faiss.extra_wrappers in faiss

NAME
    faiss.extra_wrappers

DESCRIPTION
    # Copyright (c) Facebook, Inc. and its affiliates.
    #
    # This source code is licensed under the MIT license found in the
    # LICENSE file in the root directory of this source tree.

CLASSES
    builtins.object
        Kmeans
            SuperKmeans
        MapInt64ToInt64
        ResultHeap

    class Kmeans(builtins.object)
     |  Kmeans(d, k, **kwargs)
     |
     |  Object that performs k-means clustering and manages the centroids.
     |  The `Kmeans` class is essentially a wrapper around the C++ `Clustering` object.
     |
     |  Parameters
     |  ----------
     |  d : int
     |     dimension of the vectors to cluster
     |  k : int
     |     number of clusters
     |  gpu: bool or int, optional
     |     False: don't use GPU
     |     True: use all GPUs
     |     number: use this many GPUs
     |  progressive_dim_steps:
     |      use a progressive dimension clustering (with that number of steps)
     |
     |  Subsequent parameters are fields of the Clustring object. The most important are:
     |
     |  niter: int, optional
     |     clustering iterations
     |  nredo: int, optional
     |     redo clustering this many times and keep best
     |  verbose: bool, optional
     |  spherical: bool, optional
     |     do we want normalized centroids?
     |  int_centroids: bool, optional
     |     round centroids coordinates to integer
     |  seed: int, optional
     |     seed for the random number generator
     |  init_method: ClusteringInitMethod, optional
     |     centroid initialization method:
     |     - ClusteringInitMethod_RANDOM: uniform random sampling (default)
     |     - ClusteringInitMethod_KMEANS_PLUS_PLUS: k-means++ D²-weighted sampling,
     |       selects centroids with probability proportional to squared distance
     |       from existing centroids. Better quality but O(nkd) complexity.
     |     - ClusteringInitMethod_AFK_MC2: Assumption-Free K-MC², MCMC-based
     |       approximation using Metropolis-Hastings. Good quality with lower
     |       complexity than k-means++ for large k.
     |  afkmc2_chain_length: int, optional
     |     chain length for AFK-MC² initialization (default 50). Longer chains
     |     give better approximation to k-means++ but are slower.
     |
     |  Methods defined here:
     |
     |  __init__(self, d, k, **kwargs)
     |      d: input dimension, k: nb of centroids. Additional
     |      parameters are passed on the ClusteringParameters object,
     |      including niter=25, verbose=False, spherical = False
     |
     |  assign(self, x)
     |
     |  reset(self, k=None)
     |      prepare k-means object to perform a new clustering, possibly
     |      with another number of centroids
     |
     |  set_index(self)
     |
     |  train(self, x, weights=None, init_centroids=None)
     |      Perform k-means clustering.
     |      On output of the function call:
     |
     |      - the centroids are in the centroids field of size (`k`, `d`).
     |
     |      - the objective value at each iteration is in the array obj (size `niter`)
     |
     |      - detailed optimization statistics are in the array iteration_stats.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, d), `dtype` must be float32 and n should
     |          be larger than the number of clusters `k`.
     |      weights : array_like
     |          weight associated to each vector, shape `n`
     |      init_centroids : array_like
     |          initial set of centroids, shape (n, d)
     |
     |      Returns
     |      -------
     |      final_obj: float
     |          final optimization objective
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class MapInt64ToInt64(builtins.object)
     |  MapInt64ToInt64(capacity)
     |
     |  Methods defined here:
     |
     |  __init__(self, capacity)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  add(self, keys, vals)
     |
     |  lookup(self, keys)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ResultHeap(builtins.object)
     |  ResultHeap(nq, k, keep_max=False)
     |
     |  Accumulate query results from a sliced dataset. The final result will
     |  be in self.D, self.I.
     |
     |  Methods defined here:
     |
     |  __init__(self, nq, k, keep_max=False)
     |      nq: number of query vectors,
     |      k: number of results per query
     |      keep_max: keep the top-k maximum values instead of the minima
     |
     |  add_result(self, D, I)
     |      Add results for all heaps
     |      D, I should be of size (nh, nres)
     |      D, I do not need to be in a particular order (heap or sorted)
     |
     |  add_result_subset(self, subset, D, I)
     |      Add results for a subset of heaps.
     |      D, I should hold results for all the subset
     |      as a special case, if I is 1D, then all ids are assumed to be the same
     |
     |  finalize(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SuperKmeans(Kmeans)
     |  SuperKmeans(d, k, **kwargs)
     |
     |  Drop-in replacement for `Kmeans` that runs `SuperKMeans` (ADSampling +
     |  PDX progressive pruning) instead of `Clustering`. Same `centroids`, `obj`,
     |  `iteration_stats`, and `assign()` surface; additionally exposes
     |  `gemm_pruning_rates`.
     |
     |  kwargs are forwarded to `SuperKMeansParameters`. Fields not present on it
     |  (e.g. `spherical`, `int_centroids`, `nredo`, `frozen_centroids`,
     |  `init_method`, `update_index`, `early_stop_threshold`,
     |  `progressive_dim_steps`, `gpu`) raise `AttributeError`.
     |
     |  Method resolution order:
     |      SuperKmeans
     |      Kmeans
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, d, k, **kwargs)
     |      d: input dimension, k: nb of centroids. Additional
     |      parameters are passed on the ClusteringParameters object,
     |      including niter=25, verbose=False, spherical = False
     |
     |  set_index(self)
     |
     |  train(self, x, weights=None, init_centroids=None)
     |      Perform k-means clustering.
     |      On output of the function call:
     |
     |      - the centroids are in the centroids field of size (`k`, `d`).
     |
     |      - the objective value at each iteration is in the array obj (size `niter`)
     |
     |      - detailed optimization statistics are in the array iteration_stats.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, d), `dtype` must be float32 and n should
     |          be larger than the number of clusters `k`.
     |      weights : array_like
     |          weight associated to each vector, shape `n`
     |      init_centroids : array_like
     |          initial set of centroids, shape (n, d)
     |
     |      Returns
     |      -------
     |      final_obj: float
     |          final optimization objective
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Kmeans:
     |
     |  assign(self, x)
     |
     |  reset(self, k=None)
     |      prepare k-means object to perform a new clustering, possibly
     |      with another number of centroids
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Kmeans:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    bucket_sort(tab, nbucket=None, nt=0)
        Perform a bucket sort on a table of integers.

        Parameters
        ----------
        tab : array_like
            elements to sort, max value nbucket - 1
        nbucket : integer
            number of buckets, None if unknown
        nt : integer
            number of threads to use (0 = use unthreaded codepath)

        Returns
        -------
        lims : array_like
            cumulative sum of bucket sizes (size vmax + 1)
        perm : array_like
            perm[lims[i] : lims[i + 1]] contains the indices of bucket #i (size tab.size)

    checksum(a)
        compute a checksum for quick-and-dirty comparisons of arrays

    eval_intersection(I1, I2)
        size of intersection between each line of two result tables

    is_sequence(x)

    kmax(array, k)
        return k largest values (and their indices) of the lines of a
        float32 array

    kmin(array, k)
        return k smallest values (and their indices) of the lines of a
        float32 array

    knn(xq, xb, k, metric=1, metric_arg=0.0)
        Compute the k nearest neighbors of a vector without constructing an index


        Parameters
        ----------
        xq : array_like
            Query vectors, shape (nq, d) where the dimension d is that same as xb
            `dtype` must be float32.
        xb : array_like
            Database vectors, shape (nb, d) where dimension d is the same as xq
            `dtype` must be float32.
        k : int
            Number of nearest neighbors.
        metric : MetricType, optional
            distance measure to use (either METRIC_L2 or METRIC_INNER_PRODUCT)

        Returns
        -------
        D : array_like
            Distances of the nearest neighbors, shape (nq, k)
        I : array_like
            Labels of the nearest neighbors, shape (nq, k)

    knn_hamming(xq, xb, k, variant='hc')
        Compute the k nearest neighbors of a set of vectors without constructing an index.

        Parameters
        ----------
        xq : array_like
            Query vectors, shape (nq, d) where d is the number of bits / 8
            `dtype` must be uint8.
        xb : array_like
            Database vectors, shape (nb, d) where d is the number of bits / 8
            `dtype` must be uint8.
        k : int
            Number of nearest neighbors.
        variant : string
            Function variant to use, either "mc" (counter) or "hc" (heap)

        Returns
        -------
        D : array_like
            Distances of the nearest neighbors, shape (nq, k)
        I : array_like
            Labels of the nearest neighbors, shape (nq, k)

    lrand = randint(n, seed=12345, vmax=None)

    matrix_bucket_sort_inplace(tab, nbucket=None, nt=0)
        Perform a bucket sort on a matrix, recording the original
        row of each element.

        Parameters
        ----------
        tab : array_like
            array of size (N, ncol) that contains the bucket ids, maximum
            value nbucket - 1.
            On output, it the elements are shuffled such that the flat array
            tab.ravel()[lims[i] : lims[i + 1]] contains the row numbers
            of each bucket entry.
        nbucket : integer
            number of buckets (the maximum value in tab should be nbucket - 1)
        nt : integer
            number of threads to use (0 = use unthreaded codepath)

        Returns
        -------
        lims : array_like
            cumulative sum of bucket sizes (size vmax + 1)

    merge_knn_results(Dall, Iall, keep_max=False)
        Merge a set of sorted knn-results obtained from different shards in a dataset
        Dall and Iall are of size (nshard, nq, k) each D[i, j] should be sorted
        returns D, I of size (nq, k) as the merged result set

    normalize_L2(x)

    pack_bitstrings(a, nbit)
        Pack a set integers (i, j) where i=0:n and j=0:M into
        n bitstrings.
        Output is an uint8 array of size (n, code_size), where code_size is
        such that at most 7 bits per code are wasted.

        If nbit is an integer: all entries takes nbit bits.
        If nbit is an array: entry (i, j) takes nbit[j] bits.

    pairwise_distances(xq, xb, metric=1, metric_arg=0)
        compute the whole pairwise distance matrix between two sets of
        vectors

    rand(n, seed=12345)

    rand_smooth_vectors(n, d, seed=1234)

    randint(n, seed=12345, vmax=None)

    randn(n, seed=12345)

    unpack_bitstrings(b, M_or_nbits, nbit=None)
        Unpack a set integers (i, j) where i=0:n and j=0:M from
        n bitstrings (encoded as uint8s).
        Input is an uint8 array of size (n, code_size), where code_size is
        such that at most 7 bits per code are wasted.

        Two forms:
        - when called with (array, M, nbit): there are M entries of size
          nbit per row
        - when called with (array, nbits): element (i, j) is encoded in
          nbits[j] bits

DATA
    APPROX_TOPK_BUCKETS_B16_D2 = 3
    APPROX_TOPK_BUCKETS_B32_D2 = 1
    APPROX_TOPK_BUCKETS_B8_D2 = 4
    APPROX_TOPK_BUCKETS_B8_D3 = 2
    ClusteringInitMethod_AFK_MC2 = 2
    ClusteringInitMethod_KMEANS_PLUS_PLUS = 1
    ClusteringInitMethod_RANDOM = 0
    EXACT_TOPK = 0
    FAISS_VERSION_MAJOR = 1
    FAISS_VERSION_MINOR = 14
    FAISS_VERSION_PATCH = 3
    Float16 = 1
    Float32 = 0
    IO_FLAG_MMAP = 1684996104
    IO_FLAG_MMAP_IFC = 512
    IO_FLAG_ONDISK_SAME_DIR = 4
    IO_FLAG_PQ_SKIP_SDC_TABLE = 32
    IO_FLAG_READ_ONLY = 2
    IO_FLAG_SKIP_IVF_DATA = 8
    IO_FLAG_SKIP_PRECOMPUTE_TABLE = 16
    IO_FLAG_SKIP_STORAGE = 1
    Int8 = 3
    METRIC_BrayCurtis = 21
    METRIC_Canberra = 20
    METRIC_GOWER = 25
    METRIC_INNER_PRODUCT = 0
    METRIC_Jaccard = 23
    METRIC_JensenShannon = 22
    METRIC_L1 = 2
    METRIC_L2 = 1
    METRIC_Linf = 3
    METRIC_Lp = 4
    METRIC_NaNEuclidean = 24
    SHARED_PTR_DISOWN = 0
    SIMDLevel_ARM_NEON = 4
    SIMDLevel_ARM_SVE = 5
    SIMDLevel_AVX2 = 1
    SIMDLevel_AVX512 = 2
    SIMDLevel_AVX512_SPR = 3
    SIMDLevel_COUNT = 7
    SIMDLevel_NONE = 0
    SIMDLevel_RISCV_RVV = 6
    SINGLE_SIMD_LEVEL = 0
    SINGLE_SIMD_LEVEL_256 = 0
    SINGLE_SIMD_LEVEL_512 = 0
    UInt8 = 2
    VERSION_STRING = '1.14.3'
    Z_MAX_BY_QB = <Swig Object of type 'float *'>
    cvar = <Swig global variables>
    hamdis_tab_ham_bytes = <Swig Object of type 'unsigned char *'>
    has_AVX2 = True
    has_AVX512 = False
    has_AVX512_SPR = False
    has_SVE = False
    instruction_sets = {'AVX', 'AVX2', 'F16C', 'FMA3', 'MMX', 'POPCNT', .....
    loaded = False
    logger = <Logger faiss.loader (WARNING)>
    opt_env_variable_name = 'FAISS_OPT_LEVEL'
    opt_level = None

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\extra_wrappers.py

Python Library Documentation: function extract_bit_fastscan in module faiss.swigfaiss

extract_bit_fastscan(code, bit_index)
     Extract bit value from FastScan code format.
    Used by IndexRaBitQFastScan which packs bits into 4-bit sub-quantizers.

    :type code: uint8_t
    :param code:          FastScan code data
    :type bit_index: int
    :param bit_index:     which bit to extract (0 to d-1)
    :rtype: boolean
    :return: bit value (true/false)

Python Library Documentation: function extract_bit_standard in module faiss.swigfaiss

extract_bit_standard(code, bit_index)
     Extract bit value from RaBitQ code in standard format.
    Used by IndexRaBitQ which stores bits sequentially.

    :type code: uint8_t
    :param code:          RaBitQ code data
    :type bit_index: int
    :param bit_index:     which bit to extract (0 to d-1)
    :rtype: boolean
    :return: bit value (true/false)

Python Library Documentation: function extract_code_inline in module faiss.swigfaiss

extract_code_inline(ex_code, index, ex_bits)
     Extract multi-bit code on-the-fly from packed ex-bit codes.
    This inline function extracts a single code value without unpacking the
    entire array, enabling efficient on-the-fly decoding during distance
    computation.

    :type ex_code: uint8_t
    :param ex_code:       packed ex-bit codes
    :type index: int
    :param index:         which code to extract (0 to d-1)
    :type ex_bits: int
    :param ex_bits:       number of bits per code (1-8)
    :rtype: int
    :return: extracted code value in range [0, 2^ex_bits - 1]

Python Library Documentation: function extract_index_ivf in module faiss.swigfaiss

extract_index_ivf(*args)
     get an IndexIVF from an index. The index may be an IndexIVF or
    some wrapper class that encloses an IndexIVF

    throws an exception if this is not the case.

Python Library Documentation: class float_maxheap_array_t in module faiss.swigfaiss

class float_maxheap_array_t(builtins.object)
 |   a template structure for a set of [min|max]-heaps it is tailored
 |  so that the actual data of the heaps can just live in compact
 |  arrays.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
 |       add nj elements to heaps i0:i0+ni, with sequential ids
 |
 |      :type nj: int
 |      :param nj:    nb of elements to add to each heap
 |      :type vin: float
 |      :param vin:   elements to add, size ni * nj
 |      :type j0: int, optional
 |      :param j0:    add this to the ids that are added
 |      :type i0: int, optional
 |      :param i0:    first heap to update
 |      :type ni: int, optional
 |      :param ni:    nb of elements to update (-1 = use nh)
 |
 |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
 |       same as addn_with_ids, but for just a subset of queries
 |
 |      :type nsubset: int
 |      :param nsubset:  number of query entries to update
 |      :type subset: int
 |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
 |
 |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
 |       same as addn
 |
 |      :type id_in: int, optional
 |      :param id_in:     ids of the elements to add, size ni * nj
 |      :type id_stride: int, optional
 |      :param id_stride: stride for id_in
 |
 |  get_ids(self, key)
 |      Corresponding identifiers
 |
 |  get_val(self, key)
 |      Return the list of values for a heap
 |
 |  heapify(self)
 |      prepare all the heaps before adding
 |
 |  per_line_extrema(self, vals_out, idx_out)
 |       this is not really a heap function. It just finds the per-line
 |        extrema of each line of array D
 |      :type vals_out: float
 |      :param vals_out:    extreme value of each line (size nh, or NULL)
 |      :type idx_out: int
 |      :param idx_out:     index of extreme value (size nh or NULL)
 |
 |  reorder(self)
 |      reorder all the heaps
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_float_maxheap_array_t(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ids
 |      identifiers (size nh * k)
 |
 |  k
 |      allocated size per heap
 |
 |  nh
 |      number of heaps
 |
 |  thisown
 |      The membership flag
 |
 |  val
 |      values (distances or similarities), size nh * k

Python Library Documentation: class float_minheap_array_t in module faiss.swigfaiss

class float_minheap_array_t(builtins.object)
 |   a template structure for a set of [min|max]-heaps it is tailored
 |  so that the actual data of the heaps can just live in compact
 |  arrays.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
 |       add nj elements to heaps i0:i0+ni, with sequential ids
 |
 |      :type nj: int
 |      :param nj:    nb of elements to add to each heap
 |      :type vin: float
 |      :param vin:   elements to add, size ni * nj
 |      :type j0: int, optional
 |      :param j0:    add this to the ids that are added
 |      :type i0: int, optional
 |      :param i0:    first heap to update
 |      :type ni: int, optional
 |      :param ni:    nb of elements to update (-1 = use nh)
 |
 |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
 |       same as addn_with_ids, but for just a subset of queries
 |
 |      :type nsubset: int
 |      :param nsubset:  number of query entries to update
 |      :type subset: int
 |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
 |
 |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
 |       same as addn
 |
 |      :type id_in: int, optional
 |      :param id_in:     ids of the elements to add, size ni * nj
 |      :type id_stride: int, optional
 |      :param id_stride: stride for id_in
 |
 |  get_ids(self, key)
 |      Corresponding identifiers
 |
 |  get_val(self, key)
 |      Return the list of values for a heap
 |
 |  heapify(self)
 |      prepare all the heaps before adding
 |
 |  per_line_extrema(self, vals_out, idx_out)
 |       this is not really a heap function. It just finds the per-line
 |        extrema of each line of array D
 |      :type vals_out: float
 |      :param vals_out:    extreme value of each line (size nh, or NULL)
 |      :type idx_out: int
 |      :param idx_out:     index of extreme value (size nh or NULL)
 |
 |  reorder(self)
 |      reorder all the heaps
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_float_minheap_array_t(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ids
 |      identifiers (size nh * k)
 |
 |  k
 |      allocated size per heap
 |
 |  nh
 |      number of heaps
 |
 |  thisown
 |      The membership flag
 |
 |  val
 |      values (distances or similarities), size nh * k

Python Library Documentation: function float_rand in module faiss.swigfaiss

float_rand(x, n, seed)

Python Library Documentation: function float_randn in module faiss.swigfaiss

float_randn(x, n, seed)

Python Library Documentation: function fourcc in module faiss.swigfaiss

fourcc(*args)
    cast a 4-character string to a uint32_t that can be written and read easily

Python Library Documentation: function fourcc_inv in module faiss.swigfaiss

fourcc_inv(*args)

Python Library Documentation: function fourcc_inv_printable in module faiss.swigfaiss

fourcc_inv_printable(x)

Python Library Documentation: function fvec2bitvec in module faiss.swigfaiss

fvec2bitvec(x, b, d)

Python Library Documentation: function fvec_L1 in module faiss.swigfaiss

fvec_L1(x, y, d)
    L1 distance

Python Library Documentation: function fvec_L2sqr in module faiss.swigfaiss

fvec_L2sqr(x, y, d)
    Squared L2 distance between two vectors

Python Library Documentation: function fvec_L2sqr_batch_4 in module faiss.swigfaiss

fvec_L2sqr_batch_4(x, y0, y1, y2, y3, d, dis0, dis1, dis2, dis3)
    Special version of L2sqr that computes 4 distances
    between x and yi, which is performance oriented.

Python Library Documentation: function fvec_L2sqr_by_idx in module faiss.swigfaiss

fvec_L2sqr_by_idx(dis, x, y, ids, d, nx, ny)
     compute the squared L2 distances between x and a subset y of ny vectors
    defined by ids

    dis(i, j) = inner_product(x(i, :), y(ids(i, j), :))

    :type dis: float
    :param dis:   output array, size nx * ny
    :type x: float
    :param x:     first-term vector, size nx * d
    :type y: float
    :param y:     second-term vector, size (max(ids) + 1) * d
    :type ids: int
    :param ids:   ids to sample from y, size nx * ny

Python Library Documentation: function fvec_L2sqr_ny in module faiss.swigfaiss

fvec_L2sqr_ny(dis, x, y, d, ny)

Python Library Documentation: function fvec_L2sqr_ny_nearest in module faiss.swigfaiss

fvec_L2sqr_ny_nearest(distances_tmp_buffer, x, y, d, ny)

Python Library Documentation: function fvec_L2sqr_ny_nearest_y_transposed in module faiss.swigfaiss

fvec_L2sqr_ny_nearest_y_transposed(distances_tmp_buffer, x, y, y_sqlen, d, d_offset, ny)

Python Library Documentation: function fvec_L2sqr_ny_transposed in module faiss.swigfaiss

fvec_L2sqr_ny_transposed(dis, x, y, y_sqlen, d, d_offset, ny)

Python Library Documentation: function fvec_Linf in module faiss.swigfaiss

fvec_Linf(x, y, d)
    infinity distance

Python Library Documentation: function fvec_add in module faiss.swigfaiss

fvec_add(*args)
    *Overload 1:*
     compute c := a + b for vectors

    c and a can overlap, c and b can overlap

    :type a: float
    :param a: size d
    :type b: float
    :param b: size d
    :type c: float
    :param c: size d

    |

    *Overload 2:*
     compute c := a + b for a, c vectors and b a scalar

    c and a can overlap

    :type a: float
    :param a: size d
    :type c: float
    :param c: size d

Python Library Documentation: function fvec_argsort in module faiss.swigfaiss

fvec_argsort(n, vals, perm)
     Indirect sort of a floating-point array

    :type n: int
    :param n:     size of the array
    :type vals: float
    :param vals:  array to sort, size n
    :type perm: int
    :param perm:  output: permutation of [0..n-1], st.
                     vals[perm[i + 1]] >= vals[perm[i]]

Python Library Documentation: function fvec_argsort_parallel in module faiss.swigfaiss

fvec_argsort_parallel(n, vals, perm)
    Same as fvec_argsort, parallelized

Python Library Documentation: function fvec_inner_product in module faiss.swigfaiss

fvec_inner_product(x, y, d)
    inner product

Python Library Documentation: function fvec_inner_product_batch_4 in module faiss.swigfaiss

fvec_inner_product_batch_4(x, y0, y1, y2, y3, d, dis0, dis1, dis2, dis3)
    Special version of inner product that computes 4 distances
    between x and yi, which is performance oriented.

Python Library Documentation: function fvec_inner_products_by_idx in module faiss.swigfaiss

fvec_inner_products_by_idx(ip, x, y, ids, d, nx, ny)
     compute the inner product between x and a subset y of ny vectors defined by
    ids

    ip(i, j) = inner_product(x(i, :), y(ids(i, j), :))

    :type ip: float
    :param ip:    output array, size nx * ny
    :type x: float
    :param x:     first-term vector, size nx * d
    :type y: float
    :param y:     second-term vector, size (max(ids) + 1) * d
    :type ids: int
    :param ids:   ids to sample from y, size nx * ny

Python Library Documentation: function fvec_inner_products_ny in module faiss.swigfaiss

fvec_inner_products_ny(ip, x, y, d, ny)

Python Library Documentation: function fvec_madd in module faiss.swigfaiss

fvec_madd(n, a, bf, b, c)
     compute c := a + bf * b for a, b and c tables

    :type n: int
    :param n:   size of the tables
    :type a: float
    :param a:   size n
    :type b: float
    :param b:   size n
    :type c: float
    :param c:   result table, size n

Python Library Documentation: function fvec_madd_and_argmin in module faiss.swigfaiss

fvec_madd_and_argmin(n, a, bf, b, c)
     same as fvec_madd, also return index of the min of the result table
    :rtype: int
    :return: index of the min of table c

Python Library Documentation: function fvec_norm_L2sqr in module faiss.swigfaiss

fvec_norm_L2sqr(x, d)
    squared norm of a vector

Python Library Documentation: function fvec_norms_L2 in module faiss.swigfaiss

fvec_norms_L2(norms, x, d, nx)
     compute the L2 norms for a set of vectors

    :type norms: float
    :param norms:    output norms, size nx
    :type x: float
    :param x:        set of vectors, size nx * d

Python Library Documentation: function fvec_norms_L2sqr in module faiss.swigfaiss

fvec_norms_L2sqr(norms, x, d, nx)
    same as fvec_norms_L2, but computes squared norms

Python Library Documentation: function fvec_renorm_L2 in module faiss.swigfaiss

fvec_renorm_L2(d, nx, x)

Python Library Documentation: function fvec_sub in module faiss.swigfaiss

fvec_sub(d, a, b, c)
     compute c := a - b for vectors

    c and a can overlap, c and b can overlap

    :type a: float
    :param a: size d
    :type b: float
    :param b: size d
    :type c: float
    :param c: size d

Python Library Documentation: function fvecs2bitvecs in module faiss.swigfaiss

fvecs2bitvecs(x, b, d, n)

Python Library Documentation: function fvecs_maybe_subsample in module faiss.swigfaiss

fvecs_maybe_subsample(d, n, nmax, x, verbose=False, seed=1234)
     random subsamples a set of vectors if there are too many of them

    :type d: int
    :param d:      dimension of the vectors
    :type n: int
    :param n:      on input: nb of input vectors, output: nb of output vectors
    :type nmax: int
    :param nmax:   max nb of vectors to keep
    :type x: float
    :param x:      input array, size *n-by-d
    :type seed: int, optional
    :param seed:   random seed to use for sampling
    :rtype: float
    :return: x or an array allocated with new [] with *n vectors

Python Library Documentation: function generalized_hamming_64 in module faiss.swigfaiss

generalized_hamming_64(a)

Python Library Documentation: function generalized_hammings_knn_hc in module faiss.swigfaiss

generalized_hammings_knn_hc(ha, a, b, nb, code_size, ordered=1)
    generalized Hamming distances (= count number of code bytes that
       are the same)

Python Library Documentation: function get_compile_options in module faiss.swigfaiss

get_compile_options()
    get compile options

Python Library Documentation: function get_cycles in module faiss.swigfaiss

get_cycles()

Python Library Documentation: function get_deserialization_lattice_r2_limit in module faiss.swigfaiss

get_deserialization_lattice_r2_limit()

Python Library Documentation: function get_deserialization_loop_limit in module faiss.swigfaiss

get_deserialization_loop_limit()

Python Library Documentation: function get_deserialization_vector_byte_limit in module faiss.swigfaiss

get_deserialization_vector_byte_limit()

Python Library Documentation: function get_extra_distance_computer in module faiss.swigfaiss

get_extra_distance_computer(d, mt, metric_arg, nb, xb)
    get a DistanceComputer that refers to this type of distance and
    indexes a flat array of size nb

Python Library Documentation: function get_invlist_range in module faiss.swigfaiss

get_invlist_range(index, i0, i1)
    Get a subset of inverted lists [i0, i1)

Python Library Documentation: function get_mem_usage_kb in module faiss.swigfaiss

get_mem_usage_kb()
    get current RSS usage in kB

Python Library Documentation: function get_num_gpus in module faiss.swigfaiss

get_num_gpus()

Python Library Documentation: function get_numeric_type_size in module faiss.swigfaiss

get_numeric_type_size(numeric_type)

Python Library Documentation: function get_version in module faiss.swigfaiss

get_version()

Python Library Documentation: function getmillisecs in module faiss.swigfaiss

getmillisecs()
    ms elapsed since some arbitrary epoch

Python Library Documentation: function gpu_profiler_start in module faiss.swigfaiss

gpu_profiler_start()

Python Library Documentation: function gpu_profiler_stop in module faiss.swigfaiss

gpu_profiler_stop()

Python Library Documentation: function gpu_sync_all_devices in module faiss.swigfaiss

gpu_sync_all_devices()

Python Library Documentation: module faiss.gpu_wrappers in faiss

NAME
    faiss.gpu_wrappers

DESCRIPTION
    # Copyright (c) Facebook, Inc. and its affiliates.
    #
    # This source code is licensed under the MIT license found in the
    # LICENSE file in the root directory of this source tree.

FUNCTIONS
    index_cpu_to_all_gpus(index, co=None, ngpu=-1)

    index_cpu_to_gpu_multiple_py(resources, index, co=None, gpus=None)
        builds the C++ vectors for the GPU indices and the
        resources. Handles the case where the resources are assigned to
        the list of GPUs

    index_cpu_to_gpus_list(index, co=None, gpus=None, ngpu=-1)
        Here we can pass list of GPU ids as a parameter or ngpu to
        use first n GPU's. gpus mut be a list or None.
        co is a GpuMultipleClonerOptions

    knn_gpu(res, xq, xb, k, D=None, I=None, metric=1, device=-1, use_cuvs=False, vectorsMemoryLimit=0, queriesMemoryLimit=0)
        Compute the k nearest neighbors of a vector on one GPU without constructing an index

        Parameters
        ----------
        res : StandardGpuResources
            GPU resources to use during computation
        xq : array_like
            Query vectors, shape (nq, d) where d is appropriate for the index.
            `dtype` must be float32.
        xb : array_like
            Database vectors, shape (nb, d) where d is appropriate for the index.
            `dtype` must be float32.
        k : int
            Number of nearest neighbors.
        D : array_like, optional
            Output array for distances of the nearest neighbors, shape (nq, k)
        I : array_like, optional
            Output array for the nearest neighbors, shape (nq, k)
        metric : MetricType, optional
            Distance measure to use (either METRIC_L2 or METRIC_INNER_PRODUCT)
        device: int, optional
            Which CUDA device in the system to run the search on. -1 indicates that
            the current thread-local device state (via cudaGetDevice) should be used
            (can also be set via torch.cuda.set_device in PyTorch)
            Otherwise, an integer 0 <= device < numDevices indicates the GPU on which
            the computation should be run
        vectorsMemoryLimit: int, optional
        queriesMemoryLimit: int, optional
            Memory limits for vectors and queries.
            If not 0, the GPU will use at most this amount of memory
            for vectors and queries respectively.
            Vectors are broken up into chunks of size vectorsMemoryLimit,
            and queries are broken up into chunks of size queriesMemoryLimit,
            including the memory required for the results.

        Returns
        -------
        D : array_like
            Distances of the nearest neighbors, shape (nq, k)
        I : array_like
            Labels of the nearest neighbors, shape (nq, k)

    pairwise_distance_gpu(res, xq, xb, D=None, metric=1, device=-1)
        Compute all pairwise distances between xq and xb on one GPU without constructing an index

        Parameters
        ----------
        res : StandardGpuResources
            GPU resources to use during computation
        xq : array_like
            Query vectors, shape (nq, d) where d is appropriate for the index.
            `dtype` must be float32.
        xb : array_like
            Database vectors, shape (nb, d) where d is appropriate for the index.
            `dtype` must be float32.
        D : array_like, optional
            Output array for all pairwise distances, shape (nq, nb)
        metric : MetricType, optional
            Distance measure to use (either METRIC_L2 or METRIC_INNER_PRODUCT)
        device: int, optional
            Which CUDA device in the system to run the search on. -1 indicates that
            the current thread-local device state (via cudaGetDevice) should be used
            (can also be set via torch.cuda.set_device in PyTorch)
            Otherwise, an integer 0 <= device < numDevices indicates the GPU on which
            the computation should be run

        Returns
        -------
        D : array_like
            All pairwise distances, shape (nq, nb)

DATA
    APPROX_TOPK_BUCKETS_B16_D2 = 3
    APPROX_TOPK_BUCKETS_B32_D2 = 1
    APPROX_TOPK_BUCKETS_B8_D2 = 4
    APPROX_TOPK_BUCKETS_B8_D3 = 2
    ClusteringInitMethod_AFK_MC2 = 2
    ClusteringInitMethod_KMEANS_PLUS_PLUS = 1
    ClusteringInitMethod_RANDOM = 0
    EXACT_TOPK = 0
    FAISS_VERSION_MAJOR = 1
    FAISS_VERSION_MINOR = 14
    FAISS_VERSION_PATCH = 3
    Float16 = 1
    Float32 = 0
    IO_FLAG_MMAP = 1684996104
    IO_FLAG_MMAP_IFC = 512
    IO_FLAG_ONDISK_SAME_DIR = 4
    IO_FLAG_PQ_SKIP_SDC_TABLE = 32
    IO_FLAG_READ_ONLY = 2
    IO_FLAG_SKIP_IVF_DATA = 8
    IO_FLAG_SKIP_PRECOMPUTE_TABLE = 16
    IO_FLAG_SKIP_STORAGE = 1
    Int8 = 3
    METRIC_BrayCurtis = 21
    METRIC_Canberra = 20
    METRIC_GOWER = 25
    METRIC_INNER_PRODUCT = 0
    METRIC_Jaccard = 23
    METRIC_JensenShannon = 22
    METRIC_L1 = 2
    METRIC_L2 = 1
    METRIC_Linf = 3
    METRIC_Lp = 4
    METRIC_NaNEuclidean = 24
    SHARED_PTR_DISOWN = 0
    SIMDLevel_ARM_NEON = 4
    SIMDLevel_ARM_SVE = 5
    SIMDLevel_AVX2 = 1
    SIMDLevel_AVX512 = 2
    SIMDLevel_AVX512_SPR = 3
    SIMDLevel_COUNT = 7
    SIMDLevel_NONE = 0
    SIMDLevel_RISCV_RVV = 6
    SINGLE_SIMD_LEVEL = 0
    SINGLE_SIMD_LEVEL_256 = 0
    SINGLE_SIMD_LEVEL_512 = 0
    UInt8 = 2
    VERSION_STRING = '1.14.3'
    Z_MAX_BY_QB = <Swig Object of type 'float *'>
    cvar = <Swig global variables>
    hamdis_tab_ham_bytes = <Swig Object of type 'unsigned char *'>
    has_AVX2 = True
    has_AVX512 = False
    has_AVX512_SPR = False
    has_SVE = False
    instruction_sets = {'AVX', 'AVX2', 'F16C', 'FMA3', 'MMX', 'POPCNT', .....
    loaded = False
    logger = <Logger faiss.loader (WARNING)>
    opt_env_variable_name = 'FAISS_OPT_LEVEL'
    opt_level = None

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\gpu_wrappers.py

Python Library Documentation: function greedy_update_nearest in module faiss.swigfaiss

greedy_update_nearest(hnsw, qdis, level, nearest, d_nearest)

Python Library Documentation: SwigPyObject in module swig_runtime_data5 object

class SwigPyObject(builtins.object)
 |  Swig object holding a C/C++ pointer
 |
 |  Methods defined here:
 |
 |  __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.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  acquire(...)
 |      acquires ownership of the pointer
 |
 |  append(...)
 |      appends another 'this' object
 |
 |  disown(...)
 |      releases ownership of the pointer
 |
 |  next(...)
 |      returns the next 'this' object
 |
 |  own(...)
 |      returns/sets ownership of the pointer
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Python Library Documentation: function hamming_count_thres in module faiss.swigfaiss

hamming_count_thres(bs1, bs2, n1, n2, ht, ncodes, nptr)

Python Library Documentation: function hamming_range_search in module faiss.swigfaiss

hamming_range_search(a, b, na, nb, radius, ncodes, result, sel=None)
    same as hammings_knn except we are doing a range search with radius

Python Library Documentation: function hammings in module faiss.swigfaiss

hammings(a, b, na, nb, nbytespercode, dis)
     Compute a set of Hamming distances between na and nb binary vectors

    :type a: uint8_t
    :param a:             size na * nbytespercode
    :type b: uint8_t
    :param b:             size nb * nbytespercode
    :type nbytespercode: int
    :param nbytespercode: should be multiple of 8
    :type dis: int
    :param dis:           output distances, size na * nb

Python Library Documentation: function hammings_knn in module faiss.swigfaiss

hammings_knn(ha, a, b, nb, ncodes, ordered)

Python Library Documentation: function hammings_knn_hc in module faiss.swigfaiss

hammings_knn_hc(*args)
     Return the k smallest Hamming distances for a set of binary query vectors,
    using a max heap.
    :type a: uint8_t
    :param a:       queries, size ha->nh * ncodes
    :type b: uint8_t
    :param b:       database, size nb * ncodes
    :type nb: int
    :param nb:      number of database vectors
    :type ncodes: int
    :param ncodes:  size of the binary codes (bytes)
    :type ordered: int
    :param ordered: if != 0: order the results by decreasing distance
                       (may be bottleneck for k/n > 0.01)
    :type approx_topk_mode: int, optional
    :param approx_topk_mode: allows to use approximate top-k facilities
                                to speedup heap

Python Library Documentation: function hammings_knn_mc in module faiss.swigfaiss

hammings_knn_mc(a, b, na, nb, k, ncodes, distances, labels, sel=None)
     Return the k smallest Hamming distances for a set of binary query vectors,
    using counting max.
    :type a: uint8_t
    :param a:       queries, size na * ncodes
    :type b: uint8_t
    :param b:       database, size nb * ncodes
    :type na: int
    :param na:      number of query vectors
    :type nb: int
    :param nb:      number of database vectors
    :type k: int
    :param k:       number of vectors/distances to return
    :type ncodes: int
    :param ncodes:  size of the binary codes (bytes)
    :type distances: int
    :param distances: output distances from each query vector to its k nearest
                       neighbors
    :type labels: int
    :param labels:  output ids of the k nearest neighbors to each query vector

Python Library Documentation: bool object

class bool(int)
 |  bool(x) -> bool
 |
 |  Returns True when the argument x is true, False otherwise.
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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)
 |
 |  __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
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, 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.
 |
 |  __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.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from int:
 |
 |  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

Python Library Documentation: bool object

class bool(int)
 |  bool(x) -> bool
 |
 |  Returns True when the argument x is true, False otherwise.
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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)
 |
 |  __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
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, 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.
 |
 |  __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.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from int:
 |
 |  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

Python Library Documentation: bool object

class bool(int)
 |  bool(x) -> bool
 |
 |  Returns True when the argument x is true, False otherwise.
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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)
 |
 |  __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
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, 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.
 |
 |  __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.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from int:
 |
 |  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

Python Library Documentation: bool object

class bool(int)
 |  bool(x) -> bool
 |
 |  Returns True when the argument x is true, False otherwise.
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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)
 |
 |  __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
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, 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.
 |
 |  __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.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from int:
 |
 |  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

Python Library Documentation: function hash_bytes in module faiss.swigfaiss

hash_bytes(bytes, n)
    A reasonable hashing function

Python Library Documentation: function hashtable_int64_to_int64_add in module faiss.swigfaiss

hashtable_int64_to_int64_add(log2_capacity, tab, n, keys, vals)

Python Library Documentation: function hashtable_int64_to_int64_init in module faiss.swigfaiss

hashtable_int64_to_int64_init(log2_capacity, tab)
     Hashtable implementation for int64 -> int64 with external storage
    implemented for fast batch add and lookup.

    tab is of size  2 * (1 << log2_capacity)
    n is the number of elements to add or search

    adding several values in a same batch: an arbitrary one gets added
    in different batches: the newer batch overwrites.
    raises an exception if capacity is exhausted.

Python Library Documentation: function hashtable_int64_to_int64_lookup in module faiss.swigfaiss

hashtable_int64_to_int64_lookup(log2_capacity, tab, n, keys, vals)

Python Library Documentation: function imbalance_factor in module faiss.swigfaiss

imbalance_factor(*args)
    *Overload 1:*
    a balanced assignment has a IF of 1, a completely unbalanced assignment has
    an IF = k.

    |

    *Overload 2:*
    same, takes a histogram as input

Python Library Documentation: function index_binary_factory in module faiss.swigfaiss

index_binary_factory(d, description, own_invlists=True)

Python Library Documentation: function index_cpu_to_all_gpus in module faiss.gpu_wrappers

index_cpu_to_all_gpus(index, co=None, ngpu=-1)

Python Library Documentation: function index_cpu_to_gpu_multiple_py in module faiss.gpu_wrappers

index_cpu_to_gpu_multiple_py(resources, index, co=None, gpus=None)
    builds the C++ vectors for the GPU indices and the
    resources. Handles the case where the resources are assigned to
    the list of GPUs

Python Library Documentation: function index_cpu_to_gpus_list in module faiss.gpu_wrappers

index_cpu_to_gpus_list(index, co=None, gpus=None, ngpu=-1)
    Here we can pass list of GPU ids as a parameter or ngpu to
    use first n GPU's. gpus mut be a list or None.
    co is a GpuMultipleClonerOptions

Python Library Documentation: function index_factory in module faiss.swigfaiss

index_factory(*args)
    Build an index with the sequence of processing steps described in
    the string.

Python Library Documentation: function initialize_IVFPQ_precomputed_table in module faiss.swigfaiss

initialize_IVFPQ_precomputed_table(use_precomputed_table, quantizer, pq, precomputed_table, by_residual, verbose)
     Pre-compute distance tables for IVFPQ with by-residual and METRIC_L2

    :type use_precomputed_table: int
    :param use_precomputed_table: (I/O)
               =-1: force disable
               =0: decide heuristically (default: use tables only if they are
                   < precomputed_tables_max_bytes), set use_precomputed_table on
        output =1: tables that work for all quantizers (size 256 * nlist * M) =2:
        specific version for MultiIndexQuantizer (much more compact)
    :type precomputed_table: faiss::AlignedTable< float,32 >
    :param precomputed_table: precomputed table to initialize

Python Library Documentation: function inner_product_to_L2sqr in module faiss.swigfaiss

inner_product_to_L2sqr(dis, nr1, nr2, n1, n2)

Python Library Documentation: module inspect

NAME
    inspect - Get useful information from live Python objects.

MODULE REFERENCE
    https://docs.python.org/3.12/library/inspect.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module encapsulates the interface provided by the internal special
    attributes (co_*, im_*, tb_*, etc.) in a friendlier fashion.
    It also provides some help for examining source code and class layout.

    Here are some of the useful functions provided by this module:

        ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
            isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
            isroutine() - check object types
        getmembers() - get members of an object that satisfy a given condition

        getfile(), getsourcefile(), getsource() - find an object's source code
        getdoc(), getcomments() - get documentation on an object
        getmodule() - determine the module that an object came from
        getclasstree() - arrange classes so as to represent their hierarchy

        getargvalues(), getcallargs() - get info about function arguments
        getfullargspec() - same, with support for Python 3 features
        formatargvalues() - format an argument spec
        getouterframes(), getinnerframes() - get info about frames
        currentframe() - get the current stack frame
        stack(), trace() - get info about frames on the stack or in a traceback

        signature() - get a Signature object for the callable

        get_annotations() - safely compute an object's annotations

CLASSES
    builtins.Exception(builtins.BaseException)
        ClassFoundException
        EndOfBlock
    builtins.object
        BlockFinder
        BoundArguments
        Parameter
        Signature
    builtins.tuple(builtins.object)
        ArgInfo
        Arguments
        Attribute
        ClosureVars
        FullArgSpec
    enum.IntFlag(builtins.int, enum.ReprEnum, enum.Flag)
        BufferFlags
    _FrameInfo(builtins.tuple)
        FrameInfo
    _Traceback(builtins.tuple)
        Traceback

    class ArgInfo(builtins.tuple)
     |  ArgInfo(args, varargs, keywords, locals)
     |
     |  ArgInfo(args, varargs, keywords, locals)
     |
     |  Method resolution order:
     |      ArgInfo
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getnewargs__(self) from collections.ArgInfo
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  __repr__(self) from collections.ArgInfo
     |      Return a nicely formatted representation string
     |
     |  _asdict(self) from collections.ArgInfo
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections.ArgInfo
     |      Return a new ArgInfo object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  _make(iterable) from collections.ArgInfo
     |      Make a new ArgInfo object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(_cls, args, varargs, keywords, locals) from namedtuple_ArgInfo.ArgInfo
     |      Create new instance of ArgInfo(args, varargs, keywords, locals)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  args
     |      Alias for field number 0
     |
     |  varargs
     |      Alias for field number 1
     |
     |  keywords
     |      Alias for field number 2
     |
     |  locals
     |      Alias for field number 3
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('args', 'varargs', 'keywords', 'locals')
     |
     |  _field_defaults = {}
     |
     |  _fields = ('args', 'varargs', 'keywords', 'locals')
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class Arguments(builtins.tuple)
     |  Arguments(args, varargs, varkw)
     |
     |  Arguments(args, varargs, varkw)
     |
     |  Method resolution order:
     |      Arguments
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getnewargs__(self) from collections.Arguments
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  __repr__(self) from collections.Arguments
     |      Return a nicely formatted representation string
     |
     |  _asdict(self) from collections.Arguments
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections.Arguments
     |      Return a new Arguments object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  _make(iterable) from collections.Arguments
     |      Make a new Arguments object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(_cls, args, varargs, varkw) from namedtuple_Arguments.Arguments
     |      Create new instance of Arguments(args, varargs, varkw)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  args
     |      Alias for field number 0
     |
     |  varargs
     |      Alias for field number 1
     |
     |  varkw
     |      Alias for field number 2
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('args', 'varargs', 'varkw')
     |
     |  _field_defaults = {}
     |
     |  _fields = ('args', 'varargs', 'varkw')
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class Attribute(builtins.tuple)
     |  Attribute(name, kind, defining_class, object)
     |
     |  Attribute(name, kind, defining_class, object)
     |
     |  Method resolution order:
     |      Attribute
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getnewargs__(self) from collections.Attribute
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  __repr__(self) from collections.Attribute
     |      Return a nicely formatted representation string
     |
     |  _asdict(self) from collections.Attribute
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections.Attribute
     |      Return a new Attribute object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  _make(iterable) from collections.Attribute
     |      Make a new Attribute object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(_cls, name, kind, defining_class, object) from namedtuple_Attribute.Attribute
     |      Create new instance of Attribute(name, kind, defining_class, object)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  name
     |      Alias for field number 0
     |
     |  kind
     |      Alias for field number 1
     |
     |  defining_class
     |      Alias for field number 2
     |
     |  object
     |      Alias for field number 3
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('name', 'kind', 'defining_class', 'object')
     |
     |  _field_defaults = {}
     |
     |  _fields = ('name', 'kind', 'defining_class', 'object')
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class BlockFinder(builtins.object)
     |  Provide a tokeneater() method to detect the end of a code block.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  tokeneater(self, type, token, srowcol, erowcol, line)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class BoundArguments(builtins.object)
     |  BoundArguments(signature, arguments)
     |
     |  Result of `Signature.bind` call.  Holds the mapping of arguments
     |  to the function's parameters.
     |
     |  Has the following public attributes:
     |
     |  * arguments : dict
     |      An ordered mutable mapping of parameters' names to arguments' values.
     |      Does not contain arguments' default values.
     |  * signature : Signature
     |      The Signature object that created this instance.
     |  * args : tuple
     |      Tuple of positional arguments values.
     |  * kwargs : dict
     |      Dict of keyword arguments values.
     |
     |  Methods defined here:
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __getstate__(self)
     |      Helper for pickle.
     |
     |  __init__(self, signature, arguments)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setstate__(self, state)
     |
     |  apply_defaults(self)
     |      Set default values for missing arguments.
     |
     |      For variable-positional arguments (*args) the default is an
     |      empty tuple.
     |
     |      For variable-keyword arguments (**kwargs) the default is an
     |      empty dict.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  args
     |
     |  kwargs
     |
     |  signature
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  arguments
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

    class BufferFlags(enum.IntFlag)
     |  BufferFlags(*values)
     |
     |  Method resolution order:
     |      BufferFlags
     |      enum.IntFlag
     |      builtins.int
     |      enum.ReprEnum
     |      enum.Flag
     |      enum.Enum
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __and__(self, other) from enum.Flag
     |
     |  __format__(self, format_spec, /) from builtins.int
     |      Convert to a string according to format_spec.
     |
     |  __invert__(self) from enum.Flag
     |
     |  __new__(cls, value) from enum.Enum
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  __or__(self, other) from enum.Flag
     |      Return self|value.
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __xor__(self, other) from enum.Flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  FORMAT = <BufferFlags.FORMAT: 4>
     |
     |  ND = <BufferFlags.ND: 8>
     |
     |  READ = <BufferFlags.READ: 256>
     |
     |  WRITABLE = <BufferFlags.WRITABLE: 1>
     |
     |  WRITE = <BufferFlags.WRITE: 512>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.IntFlag:
     |
     |  __repr__(self) from enum.Flag
     |      Return repr(self).
     |
     |  __str__ = __repr__(self, /) from builtins.int
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.int:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __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.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)
     |
     |  __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)
     |
     |  __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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, 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.
     |
     |  __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.
     |
     |  __sizeof__(self, /)
     |      Returns size in memory, in bytes.
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  __trunc__(...)
     |      Truncating an Integral returns itself.
     |
     |  as_integer_ratio(self, /)
     |      Return a pair of integers, whose ratio is equal to the original int.
     |
     |      The ratio is in lowest terms and has a positive denominator.
     |
     |      >>> (10).as_integer_ratio()
     |      (10, 1)
     |      >>> (-10).as_integer_ratio()
     |      (-10, 1)
     |      >>> (0).as_integer_ratio()
     |      (0, 1)
     |
     |  bit_count(self, /)
     |      Number of ones in the binary representation of the absolute value of self.
     |
     |      Also known as the population count.
     |
     |      >>> bin(13)
     |      '0b1101'
     |      >>> (13).bit_count()
     |      3
     |
     |  bit_length(self, /)
     |      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.
     |
     |  is_integer(self, /)
     |      Returns True. Exists for duck type compatibility with float.is_integer.
     |
     |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
     |      Return an array of bytes representing an integer.
     |
     |      length
     |        Length of bytes object to use.  An OverflowError is raised if the
     |        integer is not representable with the given number of bytes.  Default
     |        is length 1.
     |      byteorder
     |        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.  Default is to use 'big'.
     |      signed
     |        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.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.int:
     |
     |  from_bytes(bytes, byteorder='big', *, signed=False)
     |      Return the integer represented by the given array of bytes.
     |
     |      bytes
     |        Holds the array of bytes to convert.  The argument must either
     |        support the buffer protocol or be an iterable object producing bytes.
     |        Bytes and bytearray are examples of built-in objects that support the
     |        buffer protocol.
     |      byteorder
     |        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.  Default is to use 'big'.
     |      signed
     |        Indicates whether two's complement is used to represent the integer.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.int:
     |
     |  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
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.Flag:
     |
     |  __contains__(self, other)
     |      Returns True if self has at least the same flags set as other.
     |
     |  __iter__(self)
     |      Returns flags in definition order.
     |
     |  __len__(self)
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.Enum:
     |
     |  __dir__(self)
     |      Returns public methods and other interesting attributes.
     |
     |  __init__(self, *args, **kwds)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __reduce_ex__(self, proto)
     |      Helper for pickle.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class ClassFoundException(builtins.Exception)
     |  Method resolution order:
     |      ClassFoundException
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  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 ClosureVars(builtins.tuple)
     |  ClosureVars(nonlocals, globals, builtins, unbound)
     |
     |  ClosureVars(nonlocals, globals, builtins, unbound)
     |
     |  Method resolution order:
     |      ClosureVars
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getnewargs__(self) from collections.ClosureVars
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  __repr__(self) from collections.ClosureVars
     |      Return a nicely formatted representation string
     |
     |  _asdict(self) from collections.ClosureVars
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections.ClosureVars
     |      Return a new ClosureVars object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  _make(iterable) from collections.ClosureVars
     |      Make a new ClosureVars object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(_cls, nonlocals, globals, builtins, unbound) from namedtuple_ClosureVars.ClosureVars
     |      Create new instance of ClosureVars(nonlocals, globals, builtins, unbound)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  nonlocals
     |      Alias for field number 0
     |
     |  globals
     |      Alias for field number 1
     |
     |  builtins
     |      Alias for field number 2
     |
     |  unbound
     |      Alias for field number 3
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('nonlocals', 'globals', 'builtins', 'unbound')
     |
     |  _field_defaults = {}
     |
     |  _fields = ('nonlocals', 'globals', 'builtins', 'unbound')
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class EndOfBlock(builtins.Exception)
     |  Method resolution order:
     |      EndOfBlock
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  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 FrameInfo(_FrameInfo)
     |  FrameInfo(frame, filename, lineno, function, code_context, index, *, positions=None)
     |
     |  Method resolution order:
     |      FrameInfo
     |      _FrameInfo
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __repr__(self)
     |      Return a nicely formatted representation string
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(cls, frame, filename, lineno, function, code_context, index, *, positions=None)
     |      Create new instance of _FrameInfo(frame, filename, lineno, function, code_context, index)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from _FrameInfo:
     |
     |  __getnewargs__(self) from collections._FrameInfo
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  _asdict(self) from collections._FrameInfo
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections._FrameInfo
     |      Return a new _FrameInfo object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from _FrameInfo:
     |
     |  _make(iterable) from collections._FrameInfo
     |      Make a new _FrameInfo object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from _FrameInfo:
     |
     |  frame
     |      Alias for field number 0
     |
     |  filename
     |      Alias for field number 1
     |
     |  lineno
     |      Alias for field number 2
     |
     |  function
     |      Alias for field number 3
     |
     |  code_context
     |      Alias for field number 4
     |
     |  index
     |      Alias for field number 5
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from _FrameInfo:
     |
     |  __match_args__ = ('frame', 'filename', 'lineno', 'function', 'code_con...
     |
     |  _field_defaults = {}
     |
     |  _fields = ('frame', 'filename', 'lineno', 'function', 'code_context', ...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class FullArgSpec(builtins.tuple)
     |  FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)
     |
     |  FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)
     |
     |  Method resolution order:
     |      FullArgSpec
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getnewargs__(self) from collections.FullArgSpec
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  __repr__(self) from collections.FullArgSpec
     |      Return a nicely formatted representation string
     |
     |  _asdict(self) from collections.FullArgSpec
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections.FullArgSpec
     |      Return a new FullArgSpec object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  _make(iterable) from collections.FullArgSpec
     |      Make a new FullArgSpec object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(_cls, args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations) from namedtuple_FullArgSpec.FullArgSpec
     |      Create new instance of FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  args
     |      Alias for field number 0
     |
     |  varargs
     |      Alias for field number 1
     |
     |  varkw
     |      Alias for field number 2
     |
     |  defaults
     |      Alias for field number 3
     |
     |  kwonlyargs
     |      Alias for field number 4
     |
     |  kwonlydefaults
     |      Alias for field number 5
     |
     |  annotations
     |      Alias for field number 6
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs'...
     |
     |  _field_defaults = {}
     |
     |  _fields = ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs', 'kwon...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class Parameter(builtins.object)
     |  Parameter(name, kind, *, default, annotation)
     |
     |  Represents a parameter in a function signature.
     |
     |  Has the following public attributes:
     |
     |  * name : str
     |      The name of the parameter as a string.
     |  * default : object
     |      The default value for the parameter if specified.  If the
     |      parameter has no default value, this attribute is set to
     |      `Parameter.empty`.
     |  * annotation
     |      The annotation for the parameter if specified.  If the
     |      parameter has no annotation, this attribute is set to
     |      `Parameter.empty`.
     |  * kind : str
     |      Describes how argument values are bound to the parameter.
     |      Possible values: `Parameter.POSITIONAL_ONLY`,
     |      `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`,
     |      `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`.
     |
     |  Methods defined here:
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, name, kind, *, default, annotation)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __reduce__(self)
     |      Helper for pickle.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setstate__(self, state)
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  replace(self, *, name=<class 'inspect._void'>, kind=<class 'inspect._void'>, annotation=<class 'inspect._void'>, default=<class 'inspect._void'>)
     |      Creates a customized copy of the Parameter.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  annotation
     |
     |  default
     |
     |  kind
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  KEYWORD_ONLY = <_ParameterKind.KEYWORD_ONLY: 3>
     |
     |  POSITIONAL_ONLY = <_ParameterKind.POSITIONAL_ONLY: 0>
     |
     |  POSITIONAL_OR_KEYWORD = <_ParameterKind.POSITIONAL_OR_KEYWORD: 1>
     |
     |  VAR_KEYWORD = <_ParameterKind.VAR_KEYWORD: 4>
     |
     |  VAR_POSITIONAL = <_ParameterKind.VAR_POSITIONAL: 2>
     |
     |  empty = <class 'inspect._empty'>
     |      Marker object for Signature.empty and Parameter.empty.

    class Signature(builtins.object)
     |  Signature(parameters=None, *, return_annotation, __validate_parameters__=True)
     |
     |  A Signature object represents the overall signature of a function.
     |  It stores a Parameter object for each parameter accepted by the
     |  function, as well as information specific to the function itself.
     |
     |  A Signature object has the following public attributes and methods:
     |
     |  * parameters : OrderedDict
     |      An ordered mapping of parameters' names to the corresponding
     |      Parameter objects (keyword-only arguments are in the same order
     |      as listed in `code.co_varnames`).
     |  * return_annotation : object
     |      The annotation for the return type of the function if specified.
     |      If the function has no annotation for its return type, this
     |      attribute is set to `Signature.empty`.
     |  * bind(*args, **kwargs) -> BoundArguments
     |      Creates a mapping from positional and keyword arguments to
     |      parameters.
     |  * bind_partial(*args, **kwargs) -> BoundArguments
     |      Creates a partial mapping from positional and keyword arguments
     |      to parameters (simulating 'functools.partial' behavior.)
     |
     |  Methods defined here:
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, parameters=None, *, return_annotation, __validate_parameters__=True)
     |      Constructs Signature from the given list of Parameter
     |      objects and 'return_annotation'.  All arguments are optional.
     |
     |  __reduce__(self)
     |      Helper for pickle.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setstate__(self, state)
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  bind(self, /, *args, **kwargs)
     |      Get a BoundArguments object, that maps the passed `args`
     |      and `kwargs` to the function's signature.  Raises `TypeError`
     |      if the passed arguments can not be bound.
     |
     |  bind_partial(self, /, *args, **kwargs)
     |      Get a BoundArguments object, that partially maps the
     |      passed `args` and `kwargs` to the function's signature.
     |      Raises `TypeError` if the passed arguments can not be bound.
     |
     |  replace(self, *, parameters=<class 'inspect._void'>, return_annotation=<class 'inspect._void'>)
     |      Creates a customized copy of the Signature.
     |      Pass 'parameters' and/or 'return_annotation' arguments
     |      to override them in the new copy.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  from_callable(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False)
     |      Constructs Signature for the given callable object.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  parameters
     |
     |  return_annotation
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  empty = <class 'inspect._empty'>
     |      Marker object for Signature.empty and Parameter.empty.

    class Traceback(_Traceback)
     |  Traceback(filename, lineno, function, code_context, index, *, positions=None)
     |
     |  Method resolution order:
     |      Traceback
     |      _Traceback
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __repr__(self)
     |      Return a nicely formatted representation string
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(cls, filename, lineno, function, code_context, index, *, positions=None)
     |      Create new instance of _Traceback(filename, lineno, function, code_context, index)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from _Traceback:
     |
     |  __getnewargs__(self) from collections._Traceback
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  _asdict(self) from collections._Traceback
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections._Traceback
     |      Return a new _Traceback object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from _Traceback:
     |
     |  _make(iterable) from collections._Traceback
     |      Make a new _Traceback object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from _Traceback:
     |
     |  filename
     |      Alias for field number 0
     |
     |  lineno
     |      Alias for field number 1
     |
     |  function
     |      Alias for field number 2
     |
     |  code_context
     |      Alias for field number 3
     |
     |  index
     |      Alias for field number 4
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from _Traceback:
     |
     |  __match_args__ = ('filename', 'lineno', 'function', 'code_context', 'i...
     |
     |  _field_defaults = {}
     |
     |  _fields = ('filename', 'lineno', 'function', 'code_context', 'index')
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

FUNCTIONS
    classify_class_attrs(cls)
        Return list of attribute-descriptor tuples.

        For each name in dir(cls), the return list contains a 4-tuple
        with these elements:

            0. The name (a string).

            1. The kind of attribute this is, one of these strings:
                   'class method'    created via classmethod()
                   'static method'   created via staticmethod()
                   'property'        created via property()
                   'method'          any other flavor of method or descriptor
                   'data'            not a method

            2. The class which defined this attribute (a class).

            3. The object as obtained by calling getattr; if this fails, or if the
               resulting object does not live anywhere in the class' mro (including
               metaclasses) then the object is looked up in the defining class's
               dict (found by walking the mro).

        If one of the items in dir(cls) is stored in the metaclass it will now
        be discovered and not have None be listed as the class in which it was
        defined.  Any items whose home class cannot be discovered are skipped.

    cleandoc(doc)
        Clean up indentation from docstrings.

        Any whitespace that can be uniformly removed from the second line
        onwards is removed.

    currentframe()
        Return the frame of the caller or None if this is not possible.

    findsource(object)
        Return the entire source file and starting line number for an object.

        The argument may be a module, class, method, function, traceback, frame,
        or code object.  The source code is returned as a list of all the lines
        in the file and the line number indexes a line in that list.  An OSError
        is raised if the source code cannot be retrieved.

    formatannotation(annotation, base_module=None)

    formatannotationrelativeto(object)

    formatargvalues(args, varargs, varkw, locals, formatarg=<class 'str'>, formatvarargs=<function <lambda> at 0x0000011F8DB8C9A0>, formatvarkw=<function <lambda> at 0x0000011F8DB8CA40>, formatvalue=<function <lambda> at 0x0000011F8DB8CAE0>)
        Format an argument spec from the 4 values returned by getargvalues.

        The first four arguments are (args, varargs, varkw, locals).  The
        next four arguments are the corresponding optional formatting functions
        that are called to turn names and values into strings.  The ninth
        argument is an optional function to format the sequence of arguments.

    get_annotations(obj, *, globals=None, locals=None, eval_str=False)
        Compute the annotations dict for an object.

        obj may be a callable, class, or module.
        Passing in an object of any other type raises TypeError.

        Returns a dict.  get_annotations() returns a new dict every time
        it's called; calling it twice on the same object will return two
        different but equivalent dicts.

        This function handles several details for you:

          * If eval_str is true, values of type str will
            be un-stringized using eval().  This is intended
            for use with stringized annotations
            ("from __future__ import annotations").
          * If obj doesn't have an annotations dict, returns an
            empty dict.  (Functions and methods always have an
            annotations dict; classes, modules, and other types of
            callables may not.)
          * Ignores inherited annotations on classes.  If a class
            doesn't have its own annotations dict, returns an empty dict.
          * All accesses to object members and dict values are done
            using getattr() and dict.get() for safety.
          * Always, always, always returns a freshly-created dict.

        eval_str controls whether or not values of type str are replaced
        with the result of calling eval() on those values:

          * If eval_str is true, eval() is called on values of type str.
          * If eval_str is false (the default), values of type str are unchanged.

        globals and locals are passed in to eval(); see the documentation
        for eval() for more information.  If either globals or locals is
        None, this function may replace that value with a context-specific
        default, contingent on type(obj):

          * If obj is a module, globals defaults to obj.__dict__.
          * If obj is a class, globals defaults to
            sys.modules[obj.__module__].__dict__ and locals
            defaults to the obj class namespace.
          * If obj is a callable, globals defaults to obj.__globals__,
            although if obj is a wrapped function (using
            functools.update_wrapper()) it is first unwrapped.

    getabsfile(object, _filename=None)
        Return an absolute path to the source or compiled file for an object.

        The idea is for each object to have a unique origin, so this routine
        normalizes the result as much as possible.

    getargs(co)
        Get information about the arguments accepted by a code object.

        Three things are returned: (args, varargs, varkw), where
        'args' is the list of argument names. Keyword-only arguments are
        appended. 'varargs' and 'varkw' are the names of the * and **
        arguments or None.

    getargvalues(frame)
        Get information about arguments passed into a particular frame.

        A tuple of four things is returned: (args, varargs, varkw, locals).
        'args' is a list of the argument names.
        'varargs' and 'varkw' are the names of the * and ** arguments or None.
        'locals' is the locals dictionary of the given frame.

    getasyncgenlocals(agen)
        Get the mapping of asynchronous generator local variables to their current
        values.

        A dict is returned, with the keys the local variable names and values the
        bound values.

    getasyncgenstate(agen)
        Get current state of an asynchronous generator object.

        Possible states are:
          AGEN_CREATED: Waiting to start execution.
          AGEN_RUNNING: Currently being executed by the interpreter.
          AGEN_SUSPENDED: Currently suspended at a yield expression.
          AGEN_CLOSED: Execution has completed.

    getattr_static(obj, attr, default=<object object at 0x0000011F8D3C87B0>)
        Retrieve attributes without triggering dynamic lookup via the
        descriptor protocol,  __getattr__ or __getattribute__.

        Note: this function may not be able to retrieve all attributes
        that getattr can fetch (like dynamically created attributes)
        and may find attributes that getattr can't (like descriptors
        that raise AttributeError). It can also return descriptor objects
        instead of instance members in some cases. See the
        documentation for details.

    getblock(lines)
        Extract the block of code at the top of the given list of lines.

    getcallargs(func, /, *positional, **named)
        Get the mapping of arguments to values.

        A dict is returned, with keys the function argument names (including the
        names of the * and ** arguments, if any), and values the respective bound
        values from 'positional' and 'named'.

    getclasstree(classes, unique=False)
        Arrange the given list of classes into a hierarchy of nested lists.

        Where a nested list appears, it contains classes derived from the class
        whose entry immediately precedes the list.  Each entry is a 2-tuple
        containing a class and a tuple of its base classes.  If the 'unique'
        argument is true, exactly one entry appears in the returned structure
        for each class in the given list.  Otherwise, classes using multiple
        inheritance and their descendants will appear multiple times.

    getclosurevars(func)
        Get the mapping of free variables to their current values.

        Returns a named tuple of dicts mapping the current nonlocal, global
        and builtin references as seen by the body of the function. A final
        set of unbound names that could not be resolved is also provided.

    getcomments(object)
        Get lines of comments immediately preceding an object's source code.

        Returns None when source can't be found.

    getcoroutinelocals(coroutine)
        Get the mapping of coroutine local variables to their current values.

        A dict is returned, with the keys the local variable names and values the
        bound values.

    getcoroutinestate(coroutine)
        Get current state of a coroutine object.

        Possible states are:
          CORO_CREATED: Waiting to start execution.
          CORO_RUNNING: Currently being executed by the interpreter.
          CORO_SUSPENDED: Currently suspended at an await expression.
          CORO_CLOSED: Execution has completed.

    getdoc(object)
        Get the documentation string for an object.

        All tabs are expanded to spaces.  To clean up docstrings that are
        indented to line up with blocks of code, any whitespace than can be
        uniformly removed from the second line onwards is removed.

    getfile(object)
        Work out which source or compiled file an object was defined in.

    getframeinfo(frame, context=1)
        Get information about a frame or traceback object.

        A tuple of five things is returned: the filename, the line number of
        the current line, the function name, a list of lines of context from
        the source code, and the index of the current line within that list.
        The optional second argument specifies the number of lines of context
        to return, which are centered around the current line.

    getfullargspec(func)
        Get the names and default values of a callable object's parameters.

        A tuple of seven things is returned:
        (args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations).
        'args' is a list of the parameter names.
        'varargs' and 'varkw' are the names of the * and ** parameters or None.
        'defaults' is an n-tuple of the default values of the last n parameters.
        'kwonlyargs' is a list of keyword-only parameter names.
        'kwonlydefaults' is a dictionary mapping names from kwonlyargs to defaults.
        'annotations' is a dictionary mapping parameter names to annotations.

        Notable differences from inspect.signature():
          - the "self" parameter is always reported, even for bound methods
          - wrapper chains defined by __wrapped__ *not* unwrapped automatically

    getgeneratorlocals(generator)
        Get the mapping of generator local variables to their current values.

        A dict is returned, with the keys the local variable names and values the
        bound values.

    getgeneratorstate(generator)
        Get current state of a generator-iterator.

        Possible states are:
          GEN_CREATED: Waiting to start execution.
          GEN_RUNNING: Currently being executed by the interpreter.
          GEN_SUSPENDED: Currently suspended at a yield expression.
          GEN_CLOSED: Execution has completed.

    getinnerframes(tb, context=1)
        Get a list of records for a traceback's frame and all lower frames.

        Each record contains a frame object, filename, line number, function
        name, a list of lines of context, and index within the context.

    getlineno(frame)
        Get the line number from a frame object, allowing for optimization.

    getmembers(object, predicate=None)
        Return all members of an object as (name, value) pairs sorted by name.
        Optionally, only return members that satisfy a given predicate.

    getmembers_static(object, predicate=None)
        Return all members of an object as (name, value) pairs sorted by name
        without triggering dynamic lookup via the descriptor protocol,
        __getattr__ or __getattribute__. Optionally, only return members that
        satisfy a given predicate.

        Note: this function may not be able to retrieve all members
           that getmembers can fetch (like dynamically created attributes)
           and may find members that getmembers can't (like descriptors
           that raise AttributeError). It can also return descriptor objects
           instead of instance members in some cases.

    getmodule(object, _filename=None)
        Return the module an object was defined in, or None if not found.

    getmodulename(path)
        Return the module name for a given file, or None.

    getmro(cls)
        Return tuple of base classes (including cls) in method resolution order.

    getouterframes(frame, context=1)
        Get a list of records for a frame and all higher (calling) frames.

        Each record contains a frame object, filename, line number, function
        name, a list of lines of context, and index within the context.

    getsource(object)
        Return the text of the source code for an object.

        The argument may be a module, class, method, function, traceback, frame,
        or code object.  The source code is returned as a single string.  An
        OSError is raised if the source code cannot be retrieved.

    getsourcefile(object)
        Return the filename that can be used to locate an object's source.
        Return None if no way can be identified to get the source.

    getsourcelines(object)
        Return a list of source lines and starting line number for an object.

        The argument may be a module, class, method, function, traceback, frame,
        or code object.  The source code is returned as a list of the lines
        corresponding to the object and the line number indicates where in the
        original source file the first line of code was found.  An OSError is
        raised if the source code cannot be retrieved.

    indentsize(line)
        Return the indent size, in spaces, at the start of a line of text.

    isabstract(object)
        Return true if the object is an abstract base class (ABC).

    isasyncgen(object)
        Return true if the object is an asynchronous generator.

    isasyncgenfunction(obj)
        Return true if the object is an asynchronous generator function.

        Asynchronous generator functions are defined with "async def"
        syntax and have "yield" expressions in their body.

    isawaitable(object)
        Return true if object can be passed to an ``await`` expression.

    isbuiltin(object)
        Return true if the object is a built-in function or method.

        Built-in functions and methods provide these attributes:
            __doc__         documentation string
            __name__        original name of this function or method
            __self__        instance to which a method is bound, or None

    isclass(object)
        Return true if the object is a class.

    iscode(object)
        Return true if the object is a code object.

        Code objects provide these attributes:
            co_argcount         number of arguments (not including *, ** args
                                or keyword only arguments)
            co_code             string of raw compiled bytecode
            co_cellvars         tuple of names of cell variables
            co_consts           tuple of constants used in the bytecode
            co_filename         name of file in which this code object was created
            co_firstlineno      number of first line in Python source code
            co_flags            bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg
                                | 16=nested | 32=generator | 64=nofree | 128=coroutine
                                | 256=iterable_coroutine | 512=async_generator
            co_freevars         tuple of names of free variables
            co_posonlyargcount  number of positional only arguments
            co_kwonlyargcount   number of keyword only arguments (not including ** arg)
            co_lnotab           encoded mapping of line numbers to bytecode indices
            co_name             name with which this code object was defined
            co_names            tuple of names other than arguments and function locals
            co_nlocals          number of local variables
            co_stacksize        virtual machine stack space required
            co_varnames         tuple of names of arguments and local variables

    iscoroutine(object)
        Return true if the object is a coroutine.

    iscoroutinefunction(obj)
        Return true if the object is a coroutine function.

        Coroutine functions are normally defined with "async def" syntax, but may
        be marked via markcoroutinefunction.

    isdatadescriptor(object)
        Return true if the object is a data descriptor.

        Data descriptors have a __set__ or a __delete__ attribute.  Examples are
        properties (defined in Python) and getsets and members (defined in C).
        Typically, data descriptors will also have __name__ and __doc__ attributes
        (properties, getsets, and members have both of these attributes), but this
        is not guaranteed.

    isframe(object)
        Return true if the object is a frame object.

        Frame objects provide these attributes:
            f_back          next outer frame object (this frame's caller)
            f_builtins      built-in namespace seen by this frame
            f_code          code object being executed in this frame
            f_globals       global namespace seen by this frame
            f_lasti         index of last attempted instruction in bytecode
            f_lineno        current line number in Python source code
            f_locals        local namespace seen by this frame
            f_trace         tracing function for this frame, or None

    isfunction(object)
        Return true if the object is a user-defined function.

        Function objects provide these attributes:
            __doc__         documentation string
            __name__        name with which this function was defined
            __code__        code object containing compiled function bytecode
            __defaults__    tuple of any default values for arguments
            __globals__     global namespace in which this function was defined
            __annotations__ dict of parameter annotations
            __kwdefaults__  dict of keyword only parameters with defaults

    isgenerator(object)
        Return true if the object is a generator.

        Generator objects provide these attributes:
            __iter__        defined to support iteration over container
            close           raises a new GeneratorExit exception inside the
                            generator to terminate the iteration
            gi_code         code object
            gi_frame        frame object or possibly None once the generator has
                            been exhausted
            gi_running      set to 1 when generator is executing, 0 otherwise
            next            return the next item from the container
            send            resumes the generator and "sends" a value that becomes
                            the result of the current yield-expression
            throw           used to raise an exception inside the generator

    isgeneratorfunction(obj)
        Return true if the object is a user-defined generator function.

        Generator function objects provide the same attributes as functions.
        See help(isfunction) for a list of attributes.

    isgetsetdescriptor(object)
        Return true if the object is a getset descriptor.

        getset descriptors are specialized descriptors defined in extension
        modules.

    ismemberdescriptor(object)
        Return true if the object is a member descriptor.

        Member descriptors are specialized descriptors defined in extension
        modules.

    ismethod(object)
        Return true if the object is an instance method.

    ismethoddescriptor(object)
        Return true if the object is a method descriptor.

        But not if ismethod() or isclass() or isfunction() are true.

        This is new in Python 2.2, and, for example, is true of int.__add__.
        An object passing this test has a __get__ attribute but not a __set__
        attribute, but beyond that the set of attributes varies.  __name__ is
        usually sensible, and __doc__ often is.

        Methods implemented via descriptors that also pass one of the other
        tests return false from the ismethoddescriptor() test, simply because
        the other tests promise more -- you can, e.g., count on having the
        __func__ attribute (etc) when an object passes ismethod().

    ismethodwrapper(object)
        Return true if the object is a method wrapper.

    ismodule(object)
        Return true if the object is a module.

    isroutine(object)
        Return true if the object is any kind of function or method.

    istraceback(object)
        Return true if the object is a traceback.

        Traceback objects provide these attributes:
            tb_frame        frame object at this level
            tb_lasti        index of last attempted instruction in bytecode
            tb_lineno       current line number in Python source code
            tb_next         next inner traceback object (called by this level)

    markcoroutinefunction(func)
        Decorator to ensure callable is recognised as a coroutine function.

    signature(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False)
        Get a signature object for the passed callable.

    stack(context=1)
        Return a list of records for the stack above the caller's frame.

    trace(context=1)
        Return a list of records for the stack below the current exception.

    unwrap(func, *, stop=None)
        Get the object wrapped by *func*.

        Follows the chain of :attr:`__wrapped__` attributes returning the last
        object in the chain.

        *stop* is an optional callback accepting an object in the wrapper chain
        as its sole argument that allows the unwrapping to be terminated early if
        the callback returns a true value. If the callback never returns a true
        value, the last object in the chain is returned as usual. For example,
        :func:`signature` uses this to stop unwrapping if any object in the
        chain has a ``__signature__`` attribute defined.

        :exc:`ValueError` is raised if a cycle is encountered.

    walktree(classes, children, parent)
        Recursive helper function for getclasstree().

DATA
    AGEN_CLOSED = 'AGEN_CLOSED'
    AGEN_CREATED = 'AGEN_CREATED'
    AGEN_RUNNING = 'AGEN_RUNNING'
    AGEN_SUSPENDED = 'AGEN_SUSPENDED'
    CORO_CLOSED = 'CORO_CLOSED'
    CORO_CREATED = 'CORO_CREATED'
    CORO_RUNNING = 'CORO_RUNNING'
    CORO_SUSPENDED = 'CORO_SUSPENDED'
    CO_ASYNC_GENERATOR = 512
    CO_COROUTINE = 128
    CO_GENERATOR = 32
    CO_ITERABLE_COROUTINE = 256
    CO_NESTED = 16
    CO_NEWLOCALS = 2
    CO_NOFREE = 64
    CO_OPTIMIZED = 1
    CO_VARARGS = 4
    CO_VARKEYWORDS = 8
    GEN_CLOSED = 'GEN_CLOSED'
    GEN_CREATED = 'GEN_CREATED'
    GEN_RUNNING = 'GEN_RUNNING'
    GEN_SUSPENDED = 'GEN_SUSPENDED'
    TPFLAGS_IS_ABSTRACT = 1048576
    __all__ = ['AGEN_CLOSED', 'AGEN_CREATED', 'AGEN_RUNNING', 'AGEN_SUSPEN...

AUTHOR
    ('Ka-Ping Yee <ping@lfw.org>', 'Yury Selivanov <yselivanov@sprymix.com>')

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\inspect.py

Python Library Documentation: set object

class set(object)
 |  set() -> new empty set object
 |  set(iterable) -> new set object
 |
 |  Build an unordered collection of unique elements.
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __contains__(...)
 |      x.__contains__(y) <==> y in x.
 |
 |  __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.
 |
 |  __iand__(self, value, /)
 |      Return self&=value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __ior__(self, value, /)
 |      Return self|=value.
 |
 |  __isub__(self, value, /)
 |      Return self-=value.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __reduce__(...)
 |      Return state information for pickling.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(...)
 |      S.__sizeof__() -> size of S in memory, in bytes
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  add(...)
 |      Add an element to a set.
 |
 |      This has no effect if the element is already present.
 |
 |  clear(...)
 |      Remove all elements from this set.
 |
 |  copy(...)
 |      Return a shallow copy of a set.
 |
 |  difference(...)
 |      Return the difference of two or more sets as a new set.
 |
 |      (i.e. all elements that are in this set but not the others.)
 |
 |  difference_update(...)
 |      Remove all elements of another set from this set.
 |
 |  discard(...)
 |      Remove an element from a set if it is a member.
 |
 |      Unlike set.remove(), the discard() method does not raise
 |      an exception when an element is missing from the set.
 |
 |  intersection(...)
 |      Return the intersection of two sets as a new set.
 |
 |      (i.e. all elements that are in both sets.)
 |
 |  intersection_update(...)
 |      Update a set with the intersection of itself and another.
 |
 |  isdisjoint(...)
 |      Return True if two sets have a null intersection.
 |
 |  issubset(self, other, /)
 |      Test whether every element in the set is in other.
 |
 |  issuperset(self, other, /)
 |      Test whether every element in other is in the set.
 |
 |  pop(...)
 |      Remove and return an arbitrary set element.
 |      Raises KeyError if the set is empty.
 |
 |  remove(...)
 |      Remove an element from a set; it must be a member.
 |
 |      If the element is not a member, raise a KeyError.
 |
 |  symmetric_difference(...)
 |      Return the symmetric difference of two sets as a new set.
 |
 |      (i.e. all elements that are in exactly one of the sets.)
 |
 |  symmetric_difference_update(...)
 |      Update a set with the symmetric difference of itself and another.
 |
 |  union(...)
 |      Return the union of sets as a new set.
 |
 |      (i.e. all elements that are in either set.)
 |
 |  update(...)
 |      Update a set with the union of itself and others.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Python Library Documentation: function int64_rand in module faiss.swigfaiss

int64_rand(x, n, seed)

Python Library Documentation: function int64_rand_max in module faiss.swigfaiss

int64_rand_max(x, n, max, seed)

Python Library Documentation: class int_maxheap_array_t in module faiss.swigfaiss

class int_maxheap_array_t(builtins.object)
 |   a template structure for a set of [min|max]-heaps it is tailored
 |  so that the actual data of the heaps can just live in compact
 |  arrays.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
 |       add nj elements to heaps i0:i0+ni, with sequential ids
 |
 |      :type nj: int
 |      :param nj:    nb of elements to add to each heap
 |      :type vin: int
 |      :param vin:   elements to add, size ni * nj
 |      :type j0: int, optional
 |      :param j0:    add this to the ids that are added
 |      :type i0: int, optional
 |      :param i0:    first heap to update
 |      :type ni: int, optional
 |      :param ni:    nb of elements to update (-1 = use nh)
 |
 |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
 |       same as addn_with_ids, but for just a subset of queries
 |
 |      :type nsubset: int
 |      :param nsubset:  number of query entries to update
 |      :type subset: int
 |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
 |
 |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
 |       same as addn
 |
 |      :type id_in: int, optional
 |      :param id_in:     ids of the elements to add, size ni * nj
 |      :type id_stride: int, optional
 |      :param id_stride: stride for id_in
 |
 |  get_ids(self, key)
 |      Corresponding identifiers
 |
 |  get_val(self, key)
 |      Return the list of values for a heap
 |
 |  heapify(self)
 |      prepare all the heaps before adding
 |
 |  per_line_extrema(self, vals_out, idx_out)
 |       this is not really a heap function. It just finds the per-line
 |        extrema of each line of array D
 |      :type vals_out: int
 |      :param vals_out:    extreme value of each line (size nh, or NULL)
 |      :type idx_out: int
 |      :param idx_out:     index of extreme value (size nh or NULL)
 |
 |  reorder(self)
 |      reorder all the heaps
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_int_maxheap_array_t(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ids
 |      identifiers (size nh * k)
 |
 |  k
 |      allocated size per heap
 |
 |  nh
 |      number of heaps
 |
 |  thisown
 |      The membership flag
 |
 |  val
 |      values (distances or similarities), size nh * k

Python Library Documentation: class int_minheap_array_t in module faiss.swigfaiss

class int_minheap_array_t(builtins.object)
 |   a template structure for a set of [min|max]-heaps it is tailored
 |  so that the actual data of the heaps can just live in compact
 |  arrays.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
 |       add nj elements to heaps i0:i0+ni, with sequential ids
 |
 |      :type nj: int
 |      :param nj:    nb of elements to add to each heap
 |      :type vin: int
 |      :param vin:   elements to add, size ni * nj
 |      :type j0: int, optional
 |      :param j0:    add this to the ids that are added
 |      :type i0: int, optional
 |      :param i0:    first heap to update
 |      :type ni: int, optional
 |      :param ni:    nb of elements to update (-1 = use nh)
 |
 |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
 |       same as addn_with_ids, but for just a subset of queries
 |
 |      :type nsubset: int
 |      :param nsubset:  number of query entries to update
 |      :type subset: int
 |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
 |
 |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
 |       same as addn
 |
 |      :type id_in: int, optional
 |      :param id_in:     ids of the elements to add, size ni * nj
 |      :type id_stride: int, optional
 |      :param id_stride: stride for id_in
 |
 |  get_ids(self, key)
 |      Corresponding identifiers
 |
 |  get_val(self, key)
 |      Return the list of values for a heap
 |
 |  heapify(self)
 |      prepare all the heaps before adding
 |
 |  per_line_extrema(self, vals_out, idx_out)
 |       this is not really a heap function. It just finds the per-line
 |        extrema of each line of array D
 |      :type vals_out: int
 |      :param vals_out:    extreme value of each line (size nh, or NULL)
 |      :type idx_out: int
 |      :param idx_out:     index of extreme value (size nh or NULL)
 |
 |  reorder(self)
 |      reorder all the heaps
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_int_minheap_array_t(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ids
 |      identifiers (size nh * k)
 |
 |  k
 |      allocated size per heap
 |
 |  nh
 |      number of heaps
 |
 |  thisown
 |      The membership flag
 |
 |  val
 |      values (distances or similarities), size nh * k

Python Library Documentation: function is_similarity_metric in module faiss.swigfaiss

is_similarity_metric(metric_type)
    this function is used to distinguish between min and max indexes since
    we need to support similarity and dis-similarity metrics in a flexible way

Python Library Documentation: function ivec_checksum in module faiss.swigfaiss

ivec_checksum(n, a)
    compute a checksum on a table.

Python Library Documentation: function ivec_hist in module faiss.swigfaiss

ivec_hist(n, v, vmax, hist)
    compute histogram on v

Python Library Documentation: function ivf_residual_add_from_flat_codes in module faiss.swigfaiss

ivf_residual_add_from_flat_codes(ivfrq, ncode, codes, code_size=-1)
     add from codes. NB that the norm component is not used, so the code_size can
    be provided.

    :type ivfrq: :py:class:`IndexIVFResidualQuantizer`
    :param ivfrq:      index to populate with the codes
    :type codes: uint8_t
    :param codes:      codes to add, size (ncode, code_size)
    :type code_size: int, optional
    :param code_size:  override the ivfrq's code_size, useful if the norm encoding
                          is different

Python Library Documentation: function ivf_residual_from_quantizer in module faiss.swigfaiss

ivf_residual_from_quantizer(arg1, nlevel)
     Build an IndexIVFResidualQuantizer from an ResidualQuantizer, using the
    nlevel first components as coarse quantizer and the rest as codes in invlists

Python Library Documentation: function kmax in module faiss.extra_wrappers

kmax(array, k)
    return k largest values (and their indices) of the lines of a
    float32 array

Python Library Documentation: function kmeans1d in module faiss.swigfaiss

kmeans1d(x, n, nclusters, centroids)
     Exact 1D K-Means by dynamic programming

    From  "Fast Exact k-Means, k-Medians and Bregman Divergence Clustering in 1D"
    Allan Grønlund, Kasper Green Larsen, Alexander Mathiasen, Jesper Sindahl
    Nielsen, Stefan Schneider, Mingzhou Song, ArXiV'17

    Section 2.2

    https://arxiv.org/abs/1701.07204

    :type x: float
    :param x:          input 1D array
    :type n: int
    :param n:          input array length
    :type nclusters: int
    :param nclusters:  number of clusters
    :type centroids: float
    :param centroids:  output centroids, size nclusters
    :rtype: float
    :return: imbalance factor

Python Library Documentation: function kmeans_clustering in module faiss.swigfaiss

kmeans_clustering(d, n, k, x, centroids)
     simplified interface

    :type d: int
    :param d: dimension of the data
    :type n: int
    :param n: nb of training vectors
    :type k: int
    :param k: nb of output centroids
    :type x: float
    :param x: training set (size n * d)
    :type centroids: float
    :param centroids: output centroids (size k * d)
    :rtype: float
    :return: final quantization error

Python Library Documentation: function kmin in module faiss.extra_wrappers

kmin(array, k)
    return k smallest values (and their indices) of the lines of a
    float32 array

Python Library Documentation: function knn in module faiss.extra_wrappers

knn(xq, xb, k, metric=1, metric_arg=0.0)
    Compute the k nearest neighbors of a vector without constructing an index


    Parameters
    ----------
    xq : array_like
        Query vectors, shape (nq, d) where the dimension d is that same as xb
        `dtype` must be float32.
    xb : array_like
        Database vectors, shape (nb, d) where dimension d is the same as xq
        `dtype` must be float32.
    k : int
        Number of nearest neighbors.
    metric : MetricType, optional
        distance measure to use (either METRIC_L2 or METRIC_INNER_PRODUCT)

    Returns
    -------
    D : array_like
        Distances of the nearest neighbors, shape (nq, k)
    I : array_like
        Labels of the nearest neighbors, shape (nq, k)

Python Library Documentation: function knn_L2sqr in module faiss.swigfaiss

knn_L2sqr(*args)
    *Overload 1:*
     Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, for the L2 distance
    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type res: :py:class:`float_maxheap_array_t`
    :param res:  result heap structure, which also provides k. Sorted on output
    :type y_norm2: float, optional
    :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
    :type sel: :py:class:`IDSelector`, optional
    :param sel:  search in this subset of vectors

    |

    *Overload 2:*
      Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, for the L2 distance

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type distances: float
    :param distances:  output distances, size nq * k
    :type indexes: int
    :param indexes:    output vector ids, size nq * k
    :type y_norm2: float, optional
    :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
    :type sel: :py:class:`IDSelector`, optional
    :param sel:  search in this subset of vectors

    |

    *Overload 3:*
      Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, for the L2 distance

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type distances: float
    :param distances:  output distances, size nq * k
    :type indexes: int
    :param indexes:    output vector ids, size nq * k
    :type y_norm2: float, optional
    :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
    :param sel:  search in this subset of vectors

    |

    *Overload 4:*
      Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, for the L2 distance

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type distances: float
    :param distances:  output distances, size nq * k
    :type indexes: int
    :param indexes:    output vector ids, size nq * k
    :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
    :param sel:  search in this subset of vectors

Python Library Documentation: function knn_L2sqr_by_idx in module faiss.swigfaiss

knn_L2sqr_by_idx(x, y, subset, d, nx, ny, nsubset, k, vals, ids, ld_subset=-1)
     Find the nearest neighbors for nx queries in a set of ny vectors
    indexed by ids. May be useful for re-ranking a pre-selected vector list

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size (max(ids) + 1) * d
    :type subset: int
    :param subset: subset of database vectors to consider, size (nx, nsubset)
    :param res:  result structure
    :type ld_subset: int, optional
    :param ld_subset: stride for the subset array. -1: use nsubset, 0: all queries
        process the same subset

Python Library Documentation: function knn_extra_metrics in module faiss.swigfaiss

knn_extra_metrics(x, y, d, nx, ny, mt, metric_arg, k, distances, indexes, sel=None)

Python Library Documentation: function knn_gpu in module faiss.gpu_wrappers

knn_gpu(res, xq, xb, k, D=None, I=None, metric=1, device=-1, use_cuvs=False, vectorsMemoryLimit=0, queriesMemoryLimit=0)
    Compute the k nearest neighbors of a vector on one GPU without constructing an index

    Parameters
    ----------
    res : StandardGpuResources
        GPU resources to use during computation
    xq : array_like
        Query vectors, shape (nq, d) where d is appropriate for the index.
        `dtype` must be float32.
    xb : array_like
        Database vectors, shape (nb, d) where d is appropriate for the index.
        `dtype` must be float32.
    k : int
        Number of nearest neighbors.
    D : array_like, optional
        Output array for distances of the nearest neighbors, shape (nq, k)
    I : array_like, optional
        Output array for the nearest neighbors, shape (nq, k)
    metric : MetricType, optional
        Distance measure to use (either METRIC_L2 or METRIC_INNER_PRODUCT)
    device: int, optional
        Which CUDA device in the system to run the search on. -1 indicates that
        the current thread-local device state (via cudaGetDevice) should be used
        (can also be set via torch.cuda.set_device in PyTorch)
        Otherwise, an integer 0 <= device < numDevices indicates the GPU on which
        the computation should be run
    vectorsMemoryLimit: int, optional
    queriesMemoryLimit: int, optional
        Memory limits for vectors and queries.
        If not 0, the GPU will use at most this amount of memory
        for vectors and queries respectively.
        Vectors are broken up into chunks of size vectorsMemoryLimit,
        and queries are broken up into chunks of size queriesMemoryLimit,
        including the memory required for the results.

    Returns
    -------
    D : array_like
        Distances of the nearest neighbors, shape (nq, k)
    I : array_like
        Labels of the nearest neighbors, shape (nq, k)

Python Library Documentation: function knn_hamming in module faiss.extra_wrappers

knn_hamming(xq, xb, k, variant='hc')
    Compute the k nearest neighbors of a set of vectors without constructing an index.

    Parameters
    ----------
    xq : array_like
        Query vectors, shape (nq, d) where d is the number of bits / 8
        `dtype` must be uint8.
    xb : array_like
        Database vectors, shape (nb, d) where d is the number of bits / 8
        `dtype` must be uint8.
    k : int
        Number of nearest neighbors.
    variant : string
        Function variant to use, either "mc" (counter) or "hc" (heap)

    Returns
    -------
    D : array_like
        Distances of the nearest neighbors, shape (nq, k)
    I : array_like
        Labels of the nearest neighbors, shape (nq, k)

Python Library Documentation: function knn_inner_product in module faiss.swigfaiss

knn_inner_product(*args)
    *Overload 1:*
     Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, w.r.t to max inner product.

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type res: :py:class:`float_minheap_array_t`
    :param res:  result heap structure, which also provides k. Sorted on output

    |

    *Overload 2:*
      Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, for the inner product metric.

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type distances: float
    :param distances:  output distances, size nq * k
    :type indexes: int
    :param indexes:    output vector ids, size nq * k

    |

    *Overload 3:*
      Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, for the inner product metric.

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size ny * d
    :type distances: float
    :param distances:  output distances, size nq * k
    :type indexes: int
    :param indexes:    output vector ids, size nq * k

Python Library Documentation: function knn_inner_products_by_idx in module faiss.swigfaiss

knn_inner_products_by_idx(x, y, subset, d, nx, ny, nsubset, k, vals, ids, ld_ids=-1)
     Find the max inner product neighbors for nx queries in a set of ny vectors
    indexed by ids. May be useful for re-ranking a pre-selected vector list

    :type x: float
    :param x:    query vectors, size nx * d
    :type y: float
    :param y:    database vectors, size (max(ids) + 1) * d
    :type ids: int
    :param ids:  subset of database vectors to consider, size (nx, nsubset)
    :param res:  result structure
    :type ld_ids: int, optional
    :param ld_ids: stride for the ids array. -1: use nsubset, 0: all queries
        process the same subset

Python Library Documentation: function lo_build in module faiss.swigfaiss

lo_build(list_id, offset)

Python Library Documentation: function lo_listno in module faiss.swigfaiss

lo_listno(lo)

Python Library Documentation: function lo_offset in module faiss.swigfaiss

lo_offset(lo)

Python Library Documentation: bool object

class bool(int)
 |  bool(x) -> bool
 |
 |  Returns True when the argument x is true, False otherwise.
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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)
 |
 |  __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
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, 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.
 |
 |  __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.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from int:
 |
 |  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

Python Library Documentation: module faiss.loader in faiss

NAME
    faiss.loader

DESCRIPTION
    # Copyright (c) Meta Platforms, Inc. and affiliates.
    #
    # This source code is licensed under the MIT license found in the
    # LICENSE file in the root directory of this source tree.

FUNCTIONS
    supported_instruction_sets()
        Returns the set of supported CPU features, see
        https://github.com/numpy/numpy/blob/master/numpy/core/src/common/npy_cpu_features.h
        for the list of features that this set may contain per architecture.

        Example:
        >>> supported_instruction_sets()  # for x86
        {"SSE2", "AVX2", "AVX512", ...}
        >>> supported_instruction_sets()  # for PPC
        {"VSX", "VSX2", ...}
        >>> supported_instruction_sets()  # for ARM
        {"NEON", "ASIMD", ...}

DATA
    APPROX_TOPK_BUCKETS_B16_D2 = 3
    APPROX_TOPK_BUCKETS_B32_D2 = 1
    APPROX_TOPK_BUCKETS_B8_D2 = 4
    APPROX_TOPK_BUCKETS_B8_D3 = 2
    ClusteringInitMethod_AFK_MC2 = 2
    ClusteringInitMethod_KMEANS_PLUS_PLUS = 1
    ClusteringInitMethod_RANDOM = 0
    EXACT_TOPK = 0
    FAISS_VERSION_MAJOR = 1
    FAISS_VERSION_MINOR = 14
    FAISS_VERSION_PATCH = 3
    Float16 = 1
    Float32 = 0
    IO_FLAG_MMAP = 1684996104
    IO_FLAG_MMAP_IFC = 512
    IO_FLAG_ONDISK_SAME_DIR = 4
    IO_FLAG_PQ_SKIP_SDC_TABLE = 32
    IO_FLAG_READ_ONLY = 2
    IO_FLAG_SKIP_IVF_DATA = 8
    IO_FLAG_SKIP_PRECOMPUTE_TABLE = 16
    IO_FLAG_SKIP_STORAGE = 1
    Int8 = 3
    METRIC_BrayCurtis = 21
    METRIC_Canberra = 20
    METRIC_GOWER = 25
    METRIC_INNER_PRODUCT = 0
    METRIC_Jaccard = 23
    METRIC_JensenShannon = 22
    METRIC_L1 = 2
    METRIC_L2 = 1
    METRIC_Linf = 3
    METRIC_Lp = 4
    METRIC_NaNEuclidean = 24
    SHARED_PTR_DISOWN = 0
    SIMDLevel_ARM_NEON = 4
    SIMDLevel_ARM_SVE = 5
    SIMDLevel_AVX2 = 1
    SIMDLevel_AVX512 = 2
    SIMDLevel_AVX512_SPR = 3
    SIMDLevel_COUNT = 7
    SIMDLevel_NONE = 0
    SIMDLevel_RISCV_RVV = 6
    SINGLE_SIMD_LEVEL = 0
    SINGLE_SIMD_LEVEL_256 = 0
    SINGLE_SIMD_LEVEL_512 = 0
    UInt8 = 2
    VERSION_STRING = '1.14.3'
    Z_MAX_BY_QB = <Swig Object of type 'float *'>
    cvar = <Swig global variables>
    hamdis_tab_ham_bytes = <Swig Object of type 'unsigned char *'>
    has_AVX2 = True
    has_AVX512 = False
    has_AVX512_SPR = False
    has_SVE = False
    instruction_sets = {'AVX', 'AVX2', 'F16C', 'FMA3', 'MMX', 'POPCNT', .....
    loaded = False
    logger = <Logger faiss.loader (WARNING)>
    opt_env_variable_name = 'FAISS_OPT_LEVEL'
    opt_level = None

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\loader.py

Python Library Documentation: Logger in module logging object

class Logger(Filterer)
 |  Logger(name, level=0)
 |
 |  Instances of the Logger class represent a single logging channel. A
 |  "logging channel" indicates an area of an application. Exactly how an
 |  "area" is defined is up to the application developer. Since an
 |  application can have any number of areas, logging channels are identified
 |  by a unique string. Application areas can be nested (e.g. an area
 |  of "input processing" might include sub-areas "read CSV files", "read
 |  XLS files" and "read Gnumeric files"). To cater for this natural nesting,
 |  channel names are organized into a namespace hierarchy where levels are
 |  separated by periods, much like the Java or Python package namespace. So
 |  in the instance given above, channel names might be "input" for the upper
 |  level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
 |  There is no arbitrary limit to the depth of nesting.
 |
 |  Method resolution order:
 |      Logger
 |      Filterer
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, name, level=0)
 |      Initialize the logger with a name and an optional level.
 |
 |  __reduce__(self)
 |      Helper for pickle.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  addHandler(self, hdlr)
 |      Add the specified handler to this logger.
 |
 |  callHandlers(self, record)
 |      Pass a record to all relevant handlers.
 |
 |      Loop through all handlers for this logger and its parents in the
 |      logger hierarchy. If no handler was found, output a one-off error
 |      message to sys.stderr. Stop searching up the hierarchy whenever a
 |      logger with the "propagate" attribute set to zero is found - that
 |      will be the last logger whose handlers are called.
 |
 |  critical(self, msg, *args, **kwargs)
 |      Log 'msg % args' with severity 'CRITICAL'.
 |
 |      To pass exception information, use the keyword argument exc_info with
 |      a true value, e.g.
 |
 |      logger.critical("Houston, we have a %s", "major disaster", exc_info=True)
 |
 |  debug(self, msg, *args, **kwargs)
 |      Log 'msg % args' with severity 'DEBUG'.
 |
 |      To pass exception information, use the keyword argument exc_info with
 |      a true value, e.g.
 |
 |      logger.debug("Houston, we have a %s", "thorny problem", exc_info=True)
 |
 |  error(self, msg, *args, **kwargs)
 |      Log 'msg % args' with severity 'ERROR'.
 |
 |      To pass exception information, use the keyword argument exc_info with
 |      a true value, e.g.
 |
 |      logger.error("Houston, we have a %s", "major problem", exc_info=True)
 |
 |  exception(self, msg, *args, exc_info=True, **kwargs)
 |      Convenience method for logging an ERROR with exception information.
 |
 |  fatal(self, msg, *args, **kwargs)
 |      Don't use this method, use critical() instead.
 |
 |  findCaller(self, stack_info=False, stacklevel=1)
 |      Find the stack frame of the caller so that we can note the source
 |      file name, line number and function name.
 |
 |  getChild(self, suffix)
 |      Get a logger which is a descendant to this one.
 |
 |      This is a convenience method, such that
 |
 |      logging.getLogger('abc').getChild('def.ghi')
 |
 |      is the same as
 |
 |      logging.getLogger('abc.def.ghi')
 |
 |      It's useful, for example, when the parent logger is named using
 |      __name__ rather than a literal string.
 |
 |  getChildren(self)
 |
 |  getEffectiveLevel(self)
 |      Get the effective level for this logger.
 |
 |      Loop through this logger and its parents in the logger hierarchy,
 |      looking for a non-zero logging level. Return the first one found.
 |
 |  handle(self, record)
 |      Call the handlers for the specified record.
 |
 |      This method is used for unpickled records received from a socket, as
 |      well as those created locally. Logger-level filtering is applied.
 |
 |  hasHandlers(self)
 |      See if this logger has any handlers configured.
 |
 |      Loop through all handlers for this logger and its parents in the
 |      logger hierarchy. Return True if a handler was found, else False.
 |      Stop searching up the hierarchy whenever a logger with the "propagate"
 |      attribute set to zero is found - that will be the last logger which
 |      is checked for the existence of handlers.
 |
 |  info(self, msg, *args, **kwargs)
 |      Log 'msg % args' with severity 'INFO'.
 |
 |      To pass exception information, use the keyword argument exc_info with
 |      a true value, e.g.
 |
 |      logger.info("Houston, we have a %s", "notable problem", exc_info=True)
 |
 |  isEnabledFor(self, level)
 |      Is this logger enabled for level 'level'?
 |
 |  log(self, level, msg, *args, **kwargs)
 |      Log 'msg % args' with the integer severity 'level'.
 |
 |      To pass exception information, use the keyword argument exc_info with
 |      a true value, e.g.
 |
 |      logger.log(level, "We have a %s", "mysterious problem", exc_info=True)
 |
 |  makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)
 |      A factory method which can be overridden in subclasses to create
 |      specialized LogRecords.
 |
 |  removeHandler(self, hdlr)
 |      Remove the specified handler from this logger.
 |
 |  setLevel(self, level)
 |      Set the logging level of this logger.  level must be an int or a str.
 |
 |  warn(self, msg, *args, **kwargs)
 |
 |  warning(self, msg, *args, **kwargs)
 |      Log 'msg % args' with severity 'WARNING'.
 |
 |      To pass exception information, use the keyword argument exc_info with
 |      a true value, e.g.
 |
 |      logger.warning("Houston, we have a %s", "bit of a problem", exc_info=True)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  manager = <logging.Manager object>
 |
 |  root = <RootLogger root (WARNING)>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Filterer:
 |
 |  addFilter(self, filter)
 |      Add the specified filter to this handler.
 |
 |  filter(self, record)
 |      Determine if a record is loggable by consulting all the filters.
 |
 |      The default is to allow the record to be logged; any filter can veto
 |      this by returning a false value.
 |      If a filter attached to a handler returns a log record instance,
 |      then that instance is used in place of the original log record in
 |      any further processing of the event by that handler.
 |      If a filter returns any other true value, the original log record
 |      is used in any further processing of the event by that handler.
 |
 |      If none of the filters return false values, this method returns
 |      a log record.
 |      If any of the filters return a false value, this method returns
 |      a false value.
 |
 |      .. versionchanged:: 3.2
 |
 |         Allow filters to be just callables.
 |
 |      .. versionchanged:: 3.12
 |         Allow filters to return a LogRecord instead of
 |         modifying it in place.
 |
 |  removeFilter(self, filter)
 |      Remove the specified filter from this handler.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Filterer:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: package logging

NAME
    logging

MODULE REFERENCE
    https://docs.python.org/3.12/library/logging.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    Logging package for Python. Based on PEP 282 and comments thereto in
    comp.lang.python.

    Copyright (C) 2001-2022 Vinay Sajip. All Rights Reserved.

    To use, simply 'import logging' and log away!

PACKAGE CONTENTS
    config
    handlers

CLASSES
    builtins.object
        BufferingFormatter
        Filter
        Formatter
        LogRecord
        LoggerAdapter
    Filterer(builtins.object)
        Handler
            NullHandler
            StreamHandler
                FileHandler
        Logger

    class BufferingFormatter(builtins.object)
     |  BufferingFormatter(linefmt=None)
     |
     |  A formatter suitable for formatting a number of records.
     |
     |  Methods defined here:
     |
     |  __init__(self, linefmt=None)
     |      Optionally specify a formatter which will be used to format each
     |      individual record.
     |
     |  format(self, records)
     |      Format the specified records and return the result as a string.
     |
     |  formatFooter(self, records)
     |      Return the footer string for the specified records.
     |
     |  formatHeader(self, records)
     |      Return the header string for the specified records.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class FileHandler(StreamHandler)
     |  FileHandler(filename, mode='a', encoding=None, delay=False, errors=None)
     |
     |  A handler class which writes formatted logging records to disk files.
     |
     |  Method resolution order:
     |      FileHandler
     |      StreamHandler
     |      Handler
     |      Filterer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, filename, mode='a', encoding=None, delay=False, errors=None)
     |      Open the specified file and use it as the stream for logging.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  close(self)
     |      Closes the stream.
     |
     |  emit(self, record)
     |      Emit a record.
     |
     |      If the stream was not opened because 'delay' was specified in the
     |      constructor, open it before calling the superclass's emit.
     |
     |      If stream is not open, current mode is 'w' and `_closed=True`, record
     |      will not be emitted (see Issue #42378).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from StreamHandler:
     |
     |  flush(self)
     |      Flushes the stream.
     |
     |  setStream(self, stream)
     |      Sets the StreamHandler's stream to the specified value,
     |      if it is different.
     |
     |      Returns the old stream, if the stream was changed, or None
     |      if it wasn't.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from StreamHandler:
     |
     |  __class_getitem__ = GenericAlias(...)
     |      Represent a PEP 585 generic type
     |
     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from StreamHandler:
     |
     |  terminator = '\n'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Handler:
     |
     |  acquire(self)
     |      Acquire the I/O thread lock.
     |
     |  createLock(self)
     |      Acquire a thread lock for serializing access to the underlying I/O.
     |
     |  format(self, record)
     |      Format the specified record.
     |
     |      If a formatter is set, use it. Otherwise, use the default formatter
     |      for the module.
     |
     |  get_name(self)
     |
     |  handle(self, record)
     |      Conditionally emit the specified logging record.
     |
     |      Emission depends on filters which may have been added to the handler.
     |      Wrap the actual emission of the record with acquisition/release of
     |      the I/O thread lock.
     |
     |      Returns an instance of the log record that was emitted
     |      if it passed all filters, otherwise a false value is returned.
     |
     |  handleError(self, record)
     |      Handle errors which occur during an emit() call.
     |
     |      This method should be called from handlers when an exception is
     |      encountered during an emit() call. If raiseExceptions is false,
     |      exceptions get silently ignored. This is what is mostly wanted
     |      for a logging system - most users will not care about errors in
     |      the logging system, they are more interested in application errors.
     |      You could, however, replace this with a custom handler if you wish.
     |      The record which was being processed is passed in to this method.
     |
     |  release(self)
     |      Release the I/O thread lock.
     |
     |  setFormatter(self, fmt)
     |      Set the formatter for this handler.
     |
     |  setLevel(self, level)
     |      Set the logging level of this handler.  level must be an int or a str.
     |
     |  set_name(self, name)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Handler:
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Filterer:
     |
     |  addFilter(self, filter)
     |      Add the specified filter to this handler.
     |
     |  filter(self, record)
     |      Determine if a record is loggable by consulting all the filters.
     |
     |      The default is to allow the record to be logged; any filter can veto
     |      this by returning a false value.
     |      If a filter attached to a handler returns a log record instance,
     |      then that instance is used in place of the original log record in
     |      any further processing of the event by that handler.
     |      If a filter returns any other true value, the original log record
     |      is used in any further processing of the event by that handler.
     |
     |      If none of the filters return false values, this method returns
     |      a log record.
     |      If any of the filters return a false value, this method returns
     |      a false value.
     |
     |      .. versionchanged:: 3.2
     |
     |         Allow filters to be just callables.
     |
     |      .. versionchanged:: 3.12
     |         Allow filters to return a LogRecord instead of
     |         modifying it in place.
     |
     |  removeFilter(self, filter)
     |      Remove the specified filter from this handler.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Filterer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Filter(builtins.object)
     |  Filter(name='')
     |
     |  Filter instances are used to perform arbitrary filtering of LogRecords.
     |
     |  Loggers and Handlers can optionally use Filter instances to filter
     |  records as desired. The base filter class only allows events which are
     |  below a certain point in the logger hierarchy. For example, a filter
     |  initialized with "A.B" will allow events logged by loggers "A.B",
     |  "A.B.C", "A.B.C.D", "A.B.D" etc. but not "A.BB", "B.A.B" etc. If
     |  initialized with the empty string, all events are passed.
     |
     |  Methods defined here:
     |
     |  __init__(self, name='')
     |      Initialize a filter.
     |
     |      Initialize with the name of the logger which, together with its
     |      children, will have its events allowed through the filter. If no
     |      name is specified, allow every event.
     |
     |  filter(self, record)
     |      Determine if the specified record is to be logged.
     |
     |      Returns True if the record should be logged, or False otherwise.
     |      If deemed appropriate, the record may be modified in-place.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Formatter(builtins.object)
     |  Formatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)
     |
     |  Formatter instances are used to convert a LogRecord to text.
     |
     |  Formatters need to know how a LogRecord is constructed. They are
     |  responsible for converting a LogRecord to (usually) a string which can
     |  be interpreted by either a human or an external system. The base Formatter
     |  allows a formatting string to be specified. If none is supplied, the
     |  style-dependent default value, "%(message)s", "{message}", or
     |  "${message}", is used.
     |
     |  The Formatter can be initialized with a format string which makes use of
     |  knowledge of the LogRecord attributes - e.g. the default value mentioned
     |  above makes use of the fact that the user's message and arguments are pre-
     |  formatted into a LogRecord's message attribute. Currently, the useful
     |  attributes in a LogRecord are described by:
     |
     |  %(name)s            Name of the logger (logging channel)
     |  %(levelno)s         Numeric logging level for the message (DEBUG, INFO,
     |                      WARNING, ERROR, CRITICAL)
     |  %(levelname)s       Text logging level for the message ("DEBUG", "INFO",
     |                      "WARNING", "ERROR", "CRITICAL")
     |  %(pathname)s        Full pathname of the source file where the logging
     |                      call was issued (if available)
     |  %(filename)s        Filename portion of pathname
     |  %(module)s          Module (name portion of filename)
     |  %(lineno)d          Source line number where the logging call was issued
     |                      (if available)
     |  %(funcName)s        Function name
     |  %(created)f         Time when the LogRecord was created (time.time()
     |                      return value)
     |  %(asctime)s         Textual time when the LogRecord was created
     |  %(msecs)d           Millisecond portion of the creation time
     |  %(relativeCreated)d Time in milliseconds when the LogRecord was created,
     |                      relative to the time the logging module was loaded
     |                      (typically at application startup time)
     |  %(thread)d          Thread ID (if available)
     |  %(threadName)s      Thread name (if available)
     |  %(taskName)s        Task name (if available)
     |  %(process)d         Process ID (if available)
     |  %(message)s         The result of record.getMessage(), computed just as
     |                      the record is emitted
     |
     |  Methods defined here:
     |
     |  __init__(self, fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)
     |      Initialize the formatter with specified format strings.
     |
     |      Initialize the formatter either with the specified format string, or a
     |      default as described above. Allow for specialized date formatting with
     |      the optional datefmt argument. If datefmt is omitted, you get an
     |      ISO8601-like (or RFC 3339-like) format.
     |
     |      Use a style parameter of '%', '{' or '$' to specify that you want to
     |      use one of %-formatting, :meth:`str.format` (``{}``) formatting or
     |      :class:`string.Template` formatting in your format string.
     |
     |      .. versionchanged:: 3.2
     |         Added the ``style`` parameter.
     |
     |  format(self, record)
     |      Format the specified record as text.
     |
     |      The record's attribute dictionary is used as the operand to a
     |      string formatting operation which yields the returned string.
     |      Before formatting the dictionary, a couple of preparatory steps
     |      are carried out. The message attribute of the record is computed
     |      using LogRecord.getMessage(). If the formatting string uses the
     |      time (as determined by a call to usesTime(), formatTime() is
     |      called to format the event time. If there is exception information,
     |      it is formatted using formatException() and appended to the message.
     |
     |  formatException(self, ei)
     |      Format and return the specified exception information as a string.
     |
     |      This default implementation just uses
     |      traceback.print_exception()
     |
     |  formatMessage(self, record)
     |
     |  formatStack(self, stack_info)
     |      This method is provided as an extension point for specialized
     |      formatting of stack information.
     |
     |      The input data is a string as returned from a call to
     |      :func:`traceback.print_stack`, but with the last trailing newline
     |      removed.
     |
     |      The base implementation just returns the value passed in.
     |
     |  formatTime(self, record, datefmt=None)
     |      Return the creation time of the specified LogRecord as formatted text.
     |
     |      This method should be called from format() by a formatter which
     |      wants to make use of a formatted time. This method can be overridden
     |      in formatters to provide for any specific requirement, but the
     |      basic behaviour is as follows: if datefmt (a string) is specified,
     |      it is used with time.strftime() to format the creation time of the
     |      record. Otherwise, an ISO8601-like (or RFC 3339-like) format is used.
     |      The resulting string is returned. This function uses a user-configurable
     |      function to convert the creation time to a tuple. By default,
     |      time.localtime() is used; to change this for a particular formatter
     |      instance, set the 'converter' attribute to a function with the same
     |      signature as time.localtime() or time.gmtime(). To change it for all
     |      formatters, for example if you want all logging times to be shown in GMT,
     |      set the 'converter' attribute in the Formatter class.
     |
     |  usesTime(self)
     |      Check if the format uses the creation time of the record.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  converter = localtime(...)
     |      localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
     |                                tm_sec,tm_wday,tm_yday,tm_isdst)
     |
     |      Convert seconds since the Epoch to a time tuple expressing local time.
     |      When 'seconds' is not passed in, convert the current time instead.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  default_msec_format = '%s,%03d'
     |
     |  default_time_format = '%Y-%m-%d %H:%M:%S'

    class Handler(Filterer)
     |  Handler(level=0)
     |
     |  Handler instances dispatch logging events to specific destinations.
     |
     |  The base handler class. Acts as a placeholder which defines the Handler
     |  interface. Handlers can optionally use Formatter instances to format
     |  records as desired. By default, no formatter is specified; in this case,
     |  the 'raw' message as determined by record.message is logged.
     |
     |  Method resolution order:
     |      Handler
     |      Filterer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, level=0)
     |      Initializes the instance - basically setting the formatter to None
     |      and the filter list to empty.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  acquire(self)
     |      Acquire the I/O thread lock.
     |
     |  close(self)
     |      Tidy up any resources used by the handler.
     |
     |      This version removes the handler from an internal map of handlers,
     |      _handlers, which is used for handler lookup by name. Subclasses
     |      should ensure that this gets called from overridden close()
     |      methods.
     |
     |  createLock(self)
     |      Acquire a thread lock for serializing access to the underlying I/O.
     |
     |  emit(self, record)
     |      Do whatever it takes to actually log the specified logging record.
     |
     |      This version is intended to be implemented by subclasses and so
     |      raises a NotImplementedError.
     |
     |  flush(self)
     |      Ensure all logging output has been flushed.
     |
     |      This version does nothing and is intended to be implemented by
     |      subclasses.
     |
     |  format(self, record)
     |      Format the specified record.
     |
     |      If a formatter is set, use it. Otherwise, use the default formatter
     |      for the module.
     |
     |  get_name(self)
     |
     |  handle(self, record)
     |      Conditionally emit the specified logging record.
     |
     |      Emission depends on filters which may have been added to the handler.
     |      Wrap the actual emission of the record with acquisition/release of
     |      the I/O thread lock.
     |
     |      Returns an instance of the log record that was emitted
     |      if it passed all filters, otherwise a false value is returned.
     |
     |  handleError(self, record)
     |      Handle errors which occur during an emit() call.
     |
     |      This method should be called from handlers when an exception is
     |      encountered during an emit() call. If raiseExceptions is false,
     |      exceptions get silently ignored. This is what is mostly wanted
     |      for a logging system - most users will not care about errors in
     |      the logging system, they are more interested in application errors.
     |      You could, however, replace this with a custom handler if you wish.
     |      The record which was being processed is passed in to this method.
     |
     |  release(self)
     |      Release the I/O thread lock.
     |
     |  setFormatter(self, fmt)
     |      Set the formatter for this handler.
     |
     |  setLevel(self, level)
     |      Set the logging level of this handler.  level must be an int or a str.
     |
     |  set_name(self, name)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Filterer:
     |
     |  addFilter(self, filter)
     |      Add the specified filter to this handler.
     |
     |  filter(self, record)
     |      Determine if a record is loggable by consulting all the filters.
     |
     |      The default is to allow the record to be logged; any filter can veto
     |      this by returning a false value.
     |      If a filter attached to a handler returns a log record instance,
     |      then that instance is used in place of the original log record in
     |      any further processing of the event by that handler.
     |      If a filter returns any other true value, the original log record
     |      is used in any further processing of the event by that handler.
     |
     |      If none of the filters return false values, this method returns
     |      a log record.
     |      If any of the filters return a false value, this method returns
     |      a false value.
     |
     |      .. versionchanged:: 3.2
     |
     |         Allow filters to be just callables.
     |
     |      .. versionchanged:: 3.12
     |         Allow filters to return a LogRecord instead of
     |         modifying it in place.
     |
     |  removeFilter(self, filter)
     |      Remove the specified filter from this handler.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Filterer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class LogRecord(builtins.object)
     |  LogRecord(name, level, pathname, lineno, msg, args, exc_info, func=None, sinfo=None, **kwargs)
     |
     |  A LogRecord instance represents an event being logged.
     |
     |  LogRecord instances are created every time something is logged. They
     |  contain all the information pertinent to the event being logged. The
     |  main information passed in is in msg and args, which are combined
     |  using str(msg) % args to create the message field of the record. The
     |  record also includes information such as when the record was created,
     |  the source line where the logging call was made, and any exception
     |  information to be logged.
     |
     |  Methods defined here:
     |
     |  __init__(self, name, level, pathname, lineno, msg, args, exc_info, func=None, sinfo=None, **kwargs)
     |      Initialize a logging record with interesting information.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  getMessage(self)
     |      Return the message for this LogRecord.
     |
     |      Return the message for this LogRecord after merging any user-supplied
     |      arguments with the message.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Logger(Filterer)
     |  Logger(name, level=0)
     |
     |  Instances of the Logger class represent a single logging channel. A
     |  "logging channel" indicates an area of an application. Exactly how an
     |  "area" is defined is up to the application developer. Since an
     |  application can have any number of areas, logging channels are identified
     |  by a unique string. Application areas can be nested (e.g. an area
     |  of "input processing" might include sub-areas "read CSV files", "read
     |  XLS files" and "read Gnumeric files"). To cater for this natural nesting,
     |  channel names are organized into a namespace hierarchy where levels are
     |  separated by periods, much like the Java or Python package namespace. So
     |  in the instance given above, channel names might be "input" for the upper
     |  level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
     |  There is no arbitrary limit to the depth of nesting.
     |
     |  Method resolution order:
     |      Logger
     |      Filterer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, name, level=0)
     |      Initialize the logger with a name and an optional level.
     |
     |  __reduce__(self)
     |      Helper for pickle.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  addHandler(self, hdlr)
     |      Add the specified handler to this logger.
     |
     |  callHandlers(self, record)
     |      Pass a record to all relevant handlers.
     |
     |      Loop through all handlers for this logger and its parents in the
     |      logger hierarchy. If no handler was found, output a one-off error
     |      message to sys.stderr. Stop searching up the hierarchy whenever a
     |      logger with the "propagate" attribute set to zero is found - that
     |      will be the last logger whose handlers are called.
     |
     |  critical(self, msg, *args, **kwargs)
     |      Log 'msg % args' with severity 'CRITICAL'.
     |
     |      To pass exception information, use the keyword argument exc_info with
     |      a true value, e.g.
     |
     |      logger.critical("Houston, we have a %s", "major disaster", exc_info=True)
     |
     |  debug(self, msg, *args, **kwargs)
     |      Log 'msg % args' with severity 'DEBUG'.
     |
     |      To pass exception information, use the keyword argument exc_info with
     |      a true value, e.g.
     |
     |      logger.debug("Houston, we have a %s", "thorny problem", exc_info=True)
     |
     |  error(self, msg, *args, **kwargs)
     |      Log 'msg % args' with severity 'ERROR'.
     |
     |      To pass exception information, use the keyword argument exc_info with
     |      a true value, e.g.
     |
     |      logger.error("Houston, we have a %s", "major problem", exc_info=True)
     |
     |  exception(self, msg, *args, exc_info=True, **kwargs)
     |      Convenience method for logging an ERROR with exception information.
     |
     |  fatal(self, msg, *args, **kwargs)
     |      Don't use this method, use critical() instead.
     |
     |  findCaller(self, stack_info=False, stacklevel=1)
     |      Find the stack frame of the caller so that we can note the source
     |      file name, line number and function name.
     |
     |  getChild(self, suffix)
     |      Get a logger which is a descendant to this one.
     |
     |      This is a convenience method, such that
     |
     |      logging.getLogger('abc').getChild('def.ghi')
     |
     |      is the same as
     |
     |      logging.getLogger('abc.def.ghi')
     |
     |      It's useful, for example, when the parent logger is named using
     |      __name__ rather than a literal string.
     |
     |  getChildren(self)
     |
     |  getEffectiveLevel(self)
     |      Get the effective level for this logger.
     |
     |      Loop through this logger and its parents in the logger hierarchy,
     |      looking for a non-zero logging level. Return the first one found.
     |
     |  handle(self, record)
     |      Call the handlers for the specified record.
     |
     |      This method is used for unpickled records received from a socket, as
     |      well as those created locally. Logger-level filtering is applied.
     |
     |  hasHandlers(self)
     |      See if this logger has any handlers configured.
     |
     |      Loop through all handlers for this logger and its parents in the
     |      logger hierarchy. Return True if a handler was found, else False.
     |      Stop searching up the hierarchy whenever a logger with the "propagate"
     |      attribute set to zero is found - that will be the last logger which
     |      is checked for the existence of handlers.
     |
     |  info(self, msg, *args, **kwargs)
     |      Log 'msg % args' with severity 'INFO'.
     |
     |      To pass exception information, use the keyword argument exc_info with
     |      a true value, e.g.
     |
     |      logger.info("Houston, we have a %s", "notable problem", exc_info=True)
     |
     |  isEnabledFor(self, level)
     |      Is this logger enabled for level 'level'?
     |
     |  log(self, level, msg, *args, **kwargs)
     |      Log 'msg % args' with the integer severity 'level'.
     |
     |      To pass exception information, use the keyword argument exc_info with
     |      a true value, e.g.
     |
     |      logger.log(level, "We have a %s", "mysterious problem", exc_info=True)
     |
     |  makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)
     |      A factory method which can be overridden in subclasses to create
     |      specialized LogRecords.
     |
     |  removeHandler(self, hdlr)
     |      Remove the specified handler from this logger.
     |
     |  setLevel(self, level)
     |      Set the logging level of this logger.  level must be an int or a str.
     |
     |  warn(self, msg, *args, **kwargs)
     |
     |  warning(self, msg, *args, **kwargs)
     |      Log 'msg % args' with severity 'WARNING'.
     |
     |      To pass exception information, use the keyword argument exc_info with
     |      a true value, e.g.
     |
     |      logger.warning("Houston, we have a %s", "bit of a problem", exc_info=True)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  manager = <logging.Manager object>
     |
     |  root = <RootLogger root (WARNING)>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Filterer:
     |
     |  addFilter(self, filter)
     |      Add the specified filter to this handler.
     |
     |  filter(self, record)
     |      Determine if a record is loggable by consulting all the filters.
     |
     |      The default is to allow the record to be logged; any filter can veto
     |      this by returning a false value.
     |      If a filter attached to a handler returns a log record instance,
     |      then that instance is used in place of the original log record in
     |      any further processing of the event by that handler.
     |      If a filter returns any other true value, the original log record
     |      is used in any further processing of the event by that handler.
     |
     |      If none of the filters return false values, this method returns
     |      a log record.
     |      If any of the filters return a false value, this method returns
     |      a false value.
     |
     |      .. versionchanged:: 3.2
     |
     |         Allow filters to be just callables.
     |
     |      .. versionchanged:: 3.12
     |         Allow filters to return a LogRecord instead of
     |         modifying it in place.
     |
     |  removeFilter(self, filter)
     |      Remove the specified filter from this handler.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Filterer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class LoggerAdapter(builtins.object)
     |  LoggerAdapter(logger, extra=None)
     |
     |  An adapter for loggers which makes it easier to specify contextual
     |  information in logging output.
     |
     |  Methods defined here:
     |
     |  __init__(self, logger, extra=None)
     |      Initialize the adapter with a logger and a dict-like object which
     |      provides contextual information. This constructor signature allows
     |      easy stacking of LoggerAdapters, if so desired.
     |
     |      You can effectively pass keyword arguments as shown in the
     |      following example:
     |
     |      adapter = LoggerAdapter(someLogger, dict(p1=v1, p2="v2"))
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  critical(self, msg, *args, **kwargs)
     |      Delegate a critical call to the underlying logger.
     |
     |  debug(self, msg, *args, **kwargs)
     |      Delegate a debug call to the underlying logger.
     |
     |  error(self, msg, *args, **kwargs)
     |      Delegate an error call to the underlying logger.
     |
     |  exception(self, msg, *args, exc_info=True, **kwargs)
     |      Delegate an exception call to the underlying logger.
     |
     |  getEffectiveLevel(self)
     |      Get the effective level for the underlying logger.
     |
     |  hasHandlers(self)
     |      See if the underlying logger has any handlers.
     |
     |  info(self, msg, *args, **kwargs)
     |      Delegate an info call to the underlying logger.
     |
     |  isEnabledFor(self, level)
     |      Is this logger enabled for level 'level'?
     |
     |  log(self, level, msg, *args, **kwargs)
     |      Delegate a log call to the underlying logger, after adding
     |      contextual information from this adapter instance.
     |
     |  process(self, msg, kwargs)
     |      Process the logging message and keyword arguments passed in to
     |      a logging call to insert contextual information. You can either
     |      manipulate the message itself, the keyword args or both. Return
     |      the message and kwargs modified (or not) to suit your needs.
     |
     |      Normally, you'll only need to override this one method in a
     |      LoggerAdapter subclass for your specific needs.
     |
     |  setLevel(self, level)
     |      Set the specified level on the underlying logger.
     |
     |  warn(self, msg, *args, **kwargs)
     |
     |  warning(self, msg, *args, **kwargs)
     |      Delegate a warning call to the underlying logger.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__ = GenericAlias(...)
     |      Represent a PEP 585 generic type
     |
     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  manager

    class NullHandler(Handler)
     |  NullHandler(level=0)
     |
     |  This handler does nothing. It's intended to be used to avoid the
     |  "No handlers could be found for logger XXX" one-off warning. This is
     |  important for library code, which may contain code to log events. If a user
     |  of the library does not configure logging, the one-off warning might be
     |  produced; to avoid this, the library developer simply needs to instantiate
     |  a NullHandler and add it to the top-level logger of the library module or
     |  package.
     |
     |  Method resolution order:
     |      NullHandler
     |      Handler
     |      Filterer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  createLock(self)
     |      Acquire a thread lock for serializing access to the underlying I/O.
     |
     |  emit(self, record)
     |      Stub.
     |
     |  handle(self, record)
     |      Stub.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Handler:
     |
     |  __init__(self, level=0)
     |      Initializes the instance - basically setting the formatter to None
     |      and the filter list to empty.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  acquire(self)
     |      Acquire the I/O thread lock.
     |
     |  close(self)
     |      Tidy up any resources used by the handler.
     |
     |      This version removes the handler from an internal map of handlers,
     |      _handlers, which is used for handler lookup by name. Subclasses
     |      should ensure that this gets called from overridden close()
     |      methods.
     |
     |  flush(self)
     |      Ensure all logging output has been flushed.
     |
     |      This version does nothing and is intended to be implemented by
     |      subclasses.
     |
     |  format(self, record)
     |      Format the specified record.
     |
     |      If a formatter is set, use it. Otherwise, use the default formatter
     |      for the module.
     |
     |  get_name(self)
     |
     |  handleError(self, record)
     |      Handle errors which occur during an emit() call.
     |
     |      This method should be called from handlers when an exception is
     |      encountered during an emit() call. If raiseExceptions is false,
     |      exceptions get silently ignored. This is what is mostly wanted
     |      for a logging system - most users will not care about errors in
     |      the logging system, they are more interested in application errors.
     |      You could, however, replace this with a custom handler if you wish.
     |      The record which was being processed is passed in to this method.
     |
     |  release(self)
     |      Release the I/O thread lock.
     |
     |  setFormatter(self, fmt)
     |      Set the formatter for this handler.
     |
     |  setLevel(self, level)
     |      Set the logging level of this handler.  level must be an int or a str.
     |
     |  set_name(self, name)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Handler:
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Filterer:
     |
     |  addFilter(self, filter)
     |      Add the specified filter to this handler.
     |
     |  filter(self, record)
     |      Determine if a record is loggable by consulting all the filters.
     |
     |      The default is to allow the record to be logged; any filter can veto
     |      this by returning a false value.
     |      If a filter attached to a handler returns a log record instance,
     |      then that instance is used in place of the original log record in
     |      any further processing of the event by that handler.
     |      If a filter returns any other true value, the original log record
     |      is used in any further processing of the event by that handler.
     |
     |      If none of the filters return false values, this method returns
     |      a log record.
     |      If any of the filters return a false value, this method returns
     |      a false value.
     |
     |      .. versionchanged:: 3.2
     |
     |         Allow filters to be just callables.
     |
     |      .. versionchanged:: 3.12
     |         Allow filters to return a LogRecord instead of
     |         modifying it in place.
     |
     |  removeFilter(self, filter)
     |      Remove the specified filter from this handler.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Filterer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class StreamHandler(Handler)
     |  StreamHandler(stream=None)
     |
     |  A handler class which writes logging records, appropriately formatted,
     |  to a stream. Note that this class does not close the stream, as
     |  sys.stdout or sys.stderr may be used.
     |
     |  Method resolution order:
     |      StreamHandler
     |      Handler
     |      Filterer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, stream=None)
     |      Initialize the handler.
     |
     |      If stream is not specified, sys.stderr is used.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  emit(self, record)
     |      Emit a record.
     |
     |      If a formatter is specified, it is used to format the record.
     |      The record is then written to the stream with a trailing newline.  If
     |      exception information is present, it is formatted using
     |      traceback.print_exception and appended to the stream.  If the stream
     |      has an 'encoding' attribute, it is used to determine how to do the
     |      output to the stream.
     |
     |  flush(self)
     |      Flushes the stream.
     |
     |  setStream(self, stream)
     |      Sets the StreamHandler's stream to the specified value,
     |      if it is different.
     |
     |      Returns the old stream, if the stream was changed, or None
     |      if it wasn't.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__ = GenericAlias(...)
     |      Represent a PEP 585 generic type
     |
     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  terminator = '\n'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Handler:
     |
     |  acquire(self)
     |      Acquire the I/O thread lock.
     |
     |  close(self)
     |      Tidy up any resources used by the handler.
     |
     |      This version removes the handler from an internal map of handlers,
     |      _handlers, which is used for handler lookup by name. Subclasses
     |      should ensure that this gets called from overridden close()
     |      methods.
     |
     |  createLock(self)
     |      Acquire a thread lock for serializing access to the underlying I/O.
     |
     |  format(self, record)
     |      Format the specified record.
     |
     |      If a formatter is set, use it. Otherwise, use the default formatter
     |      for the module.
     |
     |  get_name(self)
     |
     |  handle(self, record)
     |      Conditionally emit the specified logging record.
     |
     |      Emission depends on filters which may have been added to the handler.
     |      Wrap the actual emission of the record with acquisition/release of
     |      the I/O thread lock.
     |
     |      Returns an instance of the log record that was emitted
     |      if it passed all filters, otherwise a false value is returned.
     |
     |  handleError(self, record)
     |      Handle errors which occur during an emit() call.
     |
     |      This method should be called from handlers when an exception is
     |      encountered during an emit() call. If raiseExceptions is false,
     |      exceptions get silently ignored. This is what is mostly wanted
     |      for a logging system - most users will not care about errors in
     |      the logging system, they are more interested in application errors.
     |      You could, however, replace this with a custom handler if you wish.
     |      The record which was being processed is passed in to this method.
     |
     |  release(self)
     |      Release the I/O thread lock.
     |
     |  setFormatter(self, fmt)
     |      Set the formatter for this handler.
     |
     |  setLevel(self, level)
     |      Set the logging level of this handler.  level must be an int or a str.
     |
     |  set_name(self, name)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Handler:
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Filterer:
     |
     |  addFilter(self, filter)
     |      Add the specified filter to this handler.
     |
     |  filter(self, record)
     |      Determine if a record is loggable by consulting all the filters.
     |
     |      The default is to allow the record to be logged; any filter can veto
     |      this by returning a false value.
     |      If a filter attached to a handler returns a log record instance,
     |      then that instance is used in place of the original log record in
     |      any further processing of the event by that handler.
     |      If a filter returns any other true value, the original log record
     |      is used in any further processing of the event by that handler.
     |
     |      If none of the filters return false values, this method returns
     |      a log record.
     |      If any of the filters return a false value, this method returns
     |      a false value.
     |
     |      .. versionchanged:: 3.2
     |
     |         Allow filters to be just callables.
     |
     |      .. versionchanged:: 3.12
     |         Allow filters to return a LogRecord instead of
     |         modifying it in place.
     |
     |  removeFilter(self, filter)
     |      Remove the specified filter from this handler.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Filterer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    addLevelName(level, levelName)
        Associate 'levelName' with 'level'.

        This is used when converting levels to text during message formatting.

    basicConfig(**kwargs)
        Do basic configuration for the logging system.

        This function does nothing if the root logger already has handlers
        configured, unless the keyword argument *force* is set to ``True``.
        It is a convenience method intended for use by simple scripts
        to do one-shot configuration of the logging package.

        The default behaviour is to create a StreamHandler which writes to
        sys.stderr, set a formatter using the BASIC_FORMAT format string, and
        add the handler to the root logger.

        A number of optional keyword arguments may be specified, which can alter
        the default behaviour.

        filename  Specifies that a FileHandler be created, using the specified
                  filename, rather than a StreamHandler.
        filemode  Specifies the mode to open the file, if filename is specified
                  (if filemode is unspecified, it defaults to 'a').
        format    Use the specified format string for the handler.
        datefmt   Use the specified date/time format.
        style     If a format string is specified, use this to specify the
                  type of format string (possible values '%', '{', '$', for
                  %-formatting, :meth:`str.format` and :class:`string.Template`
                  - defaults to '%').
        level     Set the root logger level to the specified level.
        stream    Use the specified stream to initialize the StreamHandler. Note
                  that this argument is incompatible with 'filename' - if both
                  are present, 'stream' is ignored.
        handlers  If specified, this should be an iterable of already created
                  handlers, which will be added to the root logger. Any handler
                  in the list which does not have a formatter assigned will be
                  assigned the formatter created in this function.
        force     If this keyword  is specified as true, any existing handlers
                  attached to the root logger are removed and closed, before
                  carrying out the configuration as specified by the other
                  arguments.
        encoding  If specified together with a filename, this encoding is passed to
                  the created FileHandler, causing it to be used when the file is
                  opened.
        errors    If specified together with a filename, this value is passed to the
                  created FileHandler, causing it to be used when the file is
                  opened in text mode. If not specified, the default value is
                  `backslashreplace`.

        Note that you could specify a stream created using open(filename, mode)
        rather than passing the filename and mode in. However, it should be
        remembered that StreamHandler does not close its stream (since it may be
        using sys.stdout or sys.stderr), whereas FileHandler closes its stream
        when the handler is closed.

        .. versionchanged:: 3.2
           Added the ``style`` parameter.

        .. versionchanged:: 3.3
           Added the ``handlers`` parameter. A ``ValueError`` is now thrown for
           incompatible arguments (e.g. ``handlers`` specified together with
           ``filename``/``filemode``, or ``filename``/``filemode`` specified
           together with ``stream``, or ``handlers`` specified together with
           ``stream``.

        .. versionchanged:: 3.8
           Added the ``force`` parameter.

        .. versionchanged:: 3.9
           Added the ``encoding`` and ``errors`` parameters.

    captureWarnings(capture)
        If capture is true, redirect all warnings to the logging package.
        If capture is False, ensure that warnings are not redirected to logging
        but to their original destinations.

    critical(msg, *args, **kwargs)
        Log a message with severity 'CRITICAL' on the root logger. If the logger
        has no handlers, call basicConfig() to add a console handler with a
        pre-defined format.

    debug(msg, *args, **kwargs)
        Log a message with severity 'DEBUG' on the root logger. If the logger has
        no handlers, call basicConfig() to add a console handler with a pre-defined
        format.

    disable(level=50)
        Disable all logging calls of severity 'level' and below.

    error(msg, *args, **kwargs)
        Log a message with severity 'ERROR' on the root logger. If the logger has
        no handlers, call basicConfig() to add a console handler with a pre-defined
        format.

    exception(msg, *args, exc_info=True, **kwargs)
        Log a message with severity 'ERROR' on the root logger, with exception
        information. If the logger has no handlers, basicConfig() is called to add
        a console handler with a pre-defined format.

    fatal(msg, *args, **kwargs)
        Don't use this function, use critical() instead.

    getHandlerByName(name)
        Get a handler with the specified *name*, or None if there isn't one with
        that name.

    getHandlerNames()
        Return all known handler names as an immutable set.

    getLevelName(level)
        Return the textual or numeric representation of logging level 'level'.

        If the level is one of the predefined levels (CRITICAL, ERROR, WARNING,
        INFO, DEBUG) then you get the corresponding string. If you have
        associated levels with names using addLevelName then the name you have
        associated with 'level' is returned.

        If a numeric value corresponding to one of the defined levels is passed
        in, the corresponding string representation is returned.

        If a string representation of the level is passed in, the corresponding
        numeric value is returned.

        If no matching numeric or string value is passed in, the string
        'Level %s' % level is returned.

    getLevelNamesMapping()

    getLogRecordFactory()
        Return the factory to be used when instantiating a log record.

    getLogger(name=None)
        Return a logger with the specified name, creating it if necessary.

        If no name is specified, return the root logger.

    getLoggerClass()
        Return the class to be used when instantiating a logger.

    info(msg, *args, **kwargs)
        Log a message with severity 'INFO' on the root logger. If the logger has
        no handlers, call basicConfig() to add a console handler with a pre-defined
        format.

    log(level, msg, *args, **kwargs)
        Log 'msg % args' with the integer severity 'level' on the root logger. If
        the logger has no handlers, call basicConfig() to add a console handler
        with a pre-defined format.

    makeLogRecord(dict)
        Make a LogRecord whose attributes are defined by the specified dictionary,
        This function is useful for converting a logging event received over
        a socket connection (which is sent as a dictionary) into a LogRecord
        instance.

    setLogRecordFactory(factory)
        Set the factory to be used when instantiating a log record.

        :param factory: A callable which will be called to instantiate
        a log record.

    setLoggerClass(klass)
        Set the class to be used when instantiating a logger. The class should
        define __init__() such that only a name argument is required, and the
        __init__() should call Logger.__init__()

    shutdown(handlerList=[<weakref at 0x0000011F95C16200; to '_StderrHandler' at 0x0000011F95C253D0>])
        Perform any cleanup actions in the logging system (e.g. flushing
        buffers).

        Should be called at application exit.

    warn(msg, *args, **kwargs)

    warning(msg, *args, **kwargs)
        Log a message with severity 'WARNING' on the root logger. If the logger has
        no handlers, call basicConfig() to add a console handler with a pre-defined
        format.

DATA
    BASIC_FORMAT = '%(levelname)s:%(name)s:%(message)s'
    CRITICAL = 50
    DEBUG = 10
    ERROR = 40
    FATAL = 50
    INFO = 20
    NOTSET = 0
    WARN = 30
    WARNING = 30
    __all__ = ['BASIC_FORMAT', 'BufferingFormatter', 'CRITICAL', 'DEBUG', ...
    __status__ = 'production'
    lastResort = <_StderrHandler <stderr> (WARNING)>
    raiseExceptions = True

VERSION
    0.5.1.2

DATE
    07 February 2010

AUTHOR
    Vinay Sajip <vinay_sajip@red-dove.com>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\logging\__init__.py

Python Library Documentation: function randint in module faiss.extra_wrappers

randint(n, seed=12345, vmax=None)

Python Library Documentation: function match_hamming_thres in module faiss.swigfaiss

match_hamming_thres(bs1, bs2, n1, n2, ht, ncodes, idx, dis)

Python Library Documentation: function matrix_bucket_sort_inplace in module faiss.extra_wrappers

matrix_bucket_sort_inplace(tab, nbucket=None, nt=0)
    Perform a bucket sort on a matrix, recording the original
    row of each element.

    Parameters
    ----------
    tab : array_like
        array of size (N, ncol) that contains the bucket ids, maximum
        value nbucket - 1.
        On output, it the elements are shuffled such that the flat array
        tab.ravel()[lims[i] : lims[i + 1]] contains the row numbers
        of each bucket entry.
    nbucket : integer
        number of buckets (the maximum value in tab should be nbucket - 1)
    nt : integer
        number of threads to use (0 = use unthreaded codepath)

    Returns
    -------
    lims : array_like
        cumulative sum of bucket sizes (size vmax + 1)

Python Library Documentation: function matrix_qr in module faiss.swigfaiss

matrix_qr(m, n, a)
     compute the Q of the QR decomposition for m > n
    :type a: float
    :param a:   size n * m: input matrix and output Q

Python Library Documentation: function memcpy in module faiss.swigfaiss

memcpy(dest, src, n)

Python Library Documentation: function merge_into in module faiss.swigfaiss

merge_into(index0, index1, shift_ids)
     Merge index1 into index0. Works on IndexIVF's and IndexIVF's
     embedded in a IndexPreTransform. On output, the index1 is empty.

    :type shift_ids: boolean
    :param shift_ids:: translate the ids from index1 to index0->prev_ntotal

Python Library Documentation: function merge_knn_results in module faiss.extra_wrappers

merge_knn_results(Dall, Iall, keep_max=False)
    Merge a set of sorted knn-results obtained from different shards in a dataset
    Dall and Iall are of size (nshard, nq, k) each D[i, j] should be sorted
    returns D, I of size (nq, k) as the merged result set

Python Library Documentation: function merge_knn_results_CMax in module faiss.swigfaiss

merge_knn_results_CMax(*args)

Python Library Documentation: function merge_knn_results_CMin in module faiss.swigfaiss

merge_knn_results_CMin(*args)

Python Library Documentation: function merge_result_table_with in module faiss.swigfaiss

merge_result_table_with(n, k, I0, D0, I1, D1, keep_min=True, translation=0)
     merge a result table into another one

    :type I0: int
    :param I0:, D0       first result table, size (n, k)
    :type I1: int
    :param I1:, D1       second result table, size (n, k)
    :type keep_min: boolean, optional
    :param keep_min:     if true, keep min values, otherwise keep max
    :type translation: int, optional
    :param translation:  add this value to all I1's indexes
    :rtype: int
    :return: nb of values that were taken from the second table

Python Library Documentation: function metric_type_count in module faiss.swigfaiss

metric_type_count()
    Count of entries in the MetricType enum.

Python Library Documentation: function metric_type_from_int in module faiss.swigfaiss

metric_type_from_int(x)
    Convert an integer to MetricType with range validation.
    Throws FaissException if the value is not a valid MetricType.

Python Library Documentation: function normalize_L2 in module faiss.extra_wrappers

normalize_L2(x)

Python Library Documentation: package numpy

NAME
    numpy

DESCRIPTION
    NumPy
    =====

    Provides
      1. An array object of arbitrary homogeneous items
      2. Fast mathematical operations over arrays
      3. Linear Algebra, Fourier Transforms, Random Number Generation

    How to use the documentation
    ----------------------------
    Documentation is available in two forms: docstrings provided
    with the code, and a loose standing reference guide, available from
    `the NumPy homepage <https://numpy.org>`_.

    We recommend exploring the docstrings using
    `IPython <https://ipython.org>`_, an advanced Python shell with
    TAB-completion and introspection capabilities.  See below for further
    instructions.

    The docstring examples assume that `numpy` has been imported as ``np``::

      >>> import numpy as np

    Code snippets are indicated by three greater-than signs::

      >>> x = 42
      >>> x = x + 1

    Use the built-in ``help`` function to view a function's docstring::

      >>> help(np.sort)
      ... # doctest: +SKIP

    For some objects, ``np.info(obj)`` may provide additional help.  This is
    particularly true if you see the line "Help on ufunc object:" at the top
    of the help() page.  Ufuncs are implemented in C, not Python, for speed.
    The native Python help() does not know how to view their help, but our
    np.info() function does.

    Available subpackages
    ---------------------
    lib
        Basic functions used by several sub-packages.
    random
        Core Random Tools
    linalg
        Core Linear Algebra Tools
    fft
        Core FFT routines
    polynomial
        Polynomial tools
    testing
        NumPy testing tools
    distutils
        Enhancements to distutils with support for
        Fortran compilers support and more (for Python <= 3.11)

    Utilities
    ---------
    test
        Run numpy unittests
    show_config
        Show numpy build configuration
    __version__
        NumPy version string

    Viewing documentation using IPython
    -----------------------------------

    Start IPython and import `numpy` usually under the alias ``np``: `import
    numpy as np`.  Then, directly past or use the ``%cpaste`` magic to paste
    examples into the shell.  To see which functions are available in `numpy`,
    type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
    ``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
    down the list.  To view the docstring for a function, use
    ``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
    the source code).

    Copies vs. in-place operation
    -----------------------------
    Most of the functions in `numpy` return a copy of the array argument
    (e.g., `np.sort`).  In-place versions of these functions are often
    available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
    Exceptions to this rule are documented.

PACKAGE CONTENTS
    __config__
    _array_api_info
    _configtool
    _core (package)
    _distributor_init
    _expired_attrs_2_0
    _globals
    _pyinstaller (package)
    _pytesttester
    _typing (package)
    _utils (package)
    char (package)
    compat (package)
    conftest
    core (package)
    ctypeslib
    dtypes
    exceptions
    f2py (package)
    fft (package)
    lib (package)
    linalg (package)
    ma (package)
    matlib
    matrixlib (package)
    polynomial (package)
    random (package)
    rec (package)
    strings (package)
    testing (package)
    tests (package)
    typing (package)
    version

SUBMODULES
    _mat
    emath

CLASSES
    builtins.bytes(builtins.object)
        bytes_(builtins.bytes, character)
    builtins.object
        __array_namespace_info__
        broadcast
        busdaycalendar
        dtype
        errstate
        finfo
        flatiter
        generic
            bool
            datetime64
            flexible
                character
                    bytes_(builtins.bytes, character)
                    str_(builtins.str, character)
                void
                    record
            number
                inexact
                    complexfloating
                        clongdouble
                        complex128(complexfloating, builtins.complex)
                        complex64
                    floating
                        float16
                        float32
                        float64(floating, builtins.float)
                        longdouble
                integer
                    signedinteger
                        int16
                        int32
                        int64
                        int8
                        intc
                        timedelta64
                    unsignedinteger
                        uint16
                        uint32
                        uint64
                        uint8
                        uintc
            object_
        iinfo
        ndarray
            matrix
            memmap
            numpy.rec.recarray
        ndenumerate
        ndindex
        nditer
        poly1d
        ufunc
        vectorize
    builtins.str(builtins.object)
        str_(builtins.str, character)

    class __array_namespace_info__(builtins.object)
     |  Get the array API inspection namespace for NumPy.
     |
     |  The array API inspection namespace defines the following functions:
     |
     |  - capabilities()
     |  - default_device()
     |  - default_dtypes()
     |  - dtypes()
     |  - devices()
     |
     |  See
     |  https://data-apis.org/array-api/latest/API_specification/inspection.html
     |  for more details.
     |
     |  Returns
     |  -------
     |  info : ModuleType
     |      The array API inspection namespace for NumPy.
     |
     |  Examples
     |  --------
     |  >>> info = np.__array_namespace_info__()
     |  >>> info.default_dtypes()
     |  {'real floating': numpy.float64,
     |   'complex floating': numpy.complex128,
     |   'integral': numpy.int64,
     |   'indexing': numpy.int64}
     |
     |  Methods defined here:
     |
     |  capabilities(self) from numpy._array_api_info.__array_namespace_info__
     |      Return a dictionary of array API library capabilities.
     |
     |      The resulting dictionary has the following keys:
     |
     |      - **"boolean indexing"**: boolean indicating whether an array library
     |        supports boolean indexing. Always ``True`` for NumPy.
     |
     |      - **"data-dependent shapes"**: boolean indicating whether an array
     |        library supports data-dependent output shapes. Always ``True`` for
     |        NumPy.
     |
     |      See
     |      https://data-apis.org/array-api/latest/API_specification/generated/array_api.info.capabilities.html
     |      for more details.
     |
     |      See Also
     |      --------
     |      __array_namespace_info__.default_device,
     |      __array_namespace_info__.default_dtypes,
     |      __array_namespace_info__.dtypes,
     |      __array_namespace_info__.devices
     |
     |      Returns
     |      -------
     |      capabilities : dict
     |          A dictionary of array API library capabilities.
     |
     |      Examples
     |      --------
     |      >>> info = np.__array_namespace_info__()
     |      >>> info.capabilities()
     |      {'boolean indexing': True,
     |       'data-dependent shapes': True}
     |
     |  default_device(self) from numpy._array_api_info.__array_namespace_info__
     |      The default device used for new NumPy arrays.
     |
     |      For NumPy, this always returns ``'cpu'``.
     |
     |      See Also
     |      --------
     |      __array_namespace_info__.capabilities,
     |      __array_namespace_info__.default_dtypes,
     |      __array_namespace_info__.dtypes,
     |      __array_namespace_info__.devices
     |
     |      Returns
     |      -------
     |      device : str
     |          The default device used for new NumPy arrays.
     |
     |      Examples
     |      --------
     |      >>> info = np.__array_namespace_info__()
     |      >>> info.default_device()
     |      'cpu'
     |
     |  default_dtypes(self, *, device=None) from numpy._array_api_info.__array_namespace_info__
     |      The default data types used for new NumPy arrays.
     |
     |      For NumPy, this always returns the following dictionary:
     |
     |      - **"real floating"**: ``numpy.float64``
     |      - **"complex floating"**: ``numpy.complex128``
     |      - **"integral"**: ``numpy.intp``
     |      - **"indexing"**: ``numpy.intp``
     |
     |      Parameters
     |      ----------
     |      device : str, optional
     |          The device to get the default data types for. For NumPy, only
     |          ``'cpu'`` is allowed.
     |
     |      Returns
     |      -------
     |      dtypes : dict
     |          A dictionary describing the default data types used for new NumPy
     |          arrays.
     |
     |      See Also
     |      --------
     |      __array_namespace_info__.capabilities,
     |      __array_namespace_info__.default_device,
     |      __array_namespace_info__.dtypes,
     |      __array_namespace_info__.devices
     |
     |      Examples
     |      --------
     |      >>> info = np.__array_namespace_info__()
     |      >>> info.default_dtypes()
     |      {'real floating': numpy.float64,
     |       'complex floating': numpy.complex128,
     |       'integral': numpy.int64,
     |       'indexing': numpy.int64}
     |
     |  devices(self) from numpy._array_api_info.__array_namespace_info__
     |      The devices supported by NumPy.
     |
     |      For NumPy, this always returns ``['cpu']``.
     |
     |      Returns
     |      -------
     |      devices : list of str
     |          The devices supported by NumPy.
     |
     |      See Also
     |      --------
     |      __array_namespace_info__.capabilities,
     |      __array_namespace_info__.default_device,
     |      __array_namespace_info__.default_dtypes,
     |      __array_namespace_info__.dtypes
     |
     |      Examples
     |      --------
     |      >>> info = np.__array_namespace_info__()
     |      >>> info.devices()
     |      ['cpu']
     |
     |  dtypes(self, *, device=None, kind=None) from numpy._array_api_info.__array_namespace_info__
     |      The array API data types supported by NumPy.
     |
     |      Note that this function only returns data types that are defined by
     |      the array API.
     |
     |      Parameters
     |      ----------
     |      device : str, optional
     |          The device to get the data types for. For NumPy, only ``'cpu'`` is
     |          allowed.
     |      kind : str or tuple of str, optional
     |          The kind of data types to return. If ``None``, all data types are
     |          returned. If a string, only data types of that kind are returned.
     |          If a tuple, a dictionary containing the union of the given kinds
     |          is returned. The following kinds are supported:
     |
     |          - ``'bool'``: boolean data types (i.e., ``bool``).
     |          - ``'signed integer'``: signed integer data types (i.e., ``int8``,
     |            ``int16``, ``int32``, ``int64``).
     |          - ``'unsigned integer'``: unsigned integer data types (i.e.,
     |            ``uint8``, ``uint16``, ``uint32``, ``uint64``).
     |          - ``'integral'``: integer data types. Shorthand for ``('signed
     |            integer', 'unsigned integer')``.
     |          - ``'real floating'``: real-valued floating-point data types
     |            (i.e., ``float32``, ``float64``).
     |          - ``'complex floating'``: complex floating-point data types (i.e.,
     |            ``complex64``, ``complex128``).
     |          - ``'numeric'``: numeric data types. Shorthand for ``('integral',
     |            'real floating', 'complex floating')``.
     |
     |      Returns
     |      -------
     |      dtypes : dict
     |          A dictionary mapping the names of data types to the corresponding
     |          NumPy data types.
     |
     |      See Also
     |      --------
     |      __array_namespace_info__.capabilities,
     |      __array_namespace_info__.default_device,
     |      __array_namespace_info__.default_dtypes,
     |      __array_namespace_info__.devices
     |
     |      Examples
     |      --------
     |      >>> info = np.__array_namespace_info__()
     |      >>> info.dtypes(kind='signed integer')
     |      {'int8': numpy.int8,
     |       'int16': numpy.int16,
     |       'int32': numpy.int32,
     |       'int64': numpy.int64}
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class bool(generic)
     |  Boolean type (True or False), stored as a byte.
     |
     |  .. warning::
     |
     |     The :class:`bool` type is not a subclass of the :class:`int_` type
     |     (the :class:`bool` is not even a number type). This is different
     |     than Python's default implementation of :class:`bool` as a
     |     sub-class of :class:`int`.
     |
     |  :Character code: ``'?'``
     |
     |  Method resolution order:
     |      bool
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __eq__(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.
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(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.
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    bool_ = class bool(generic)
     |  Boolean type (True or False), stored as a byte.
     |
     |  .. warning::
     |
     |     The :class:`bool` type is not a subclass of the :class:`int_` type
     |     (the :class:`bool` is not even a number type). This is different
     |     than Python's default implementation of :class:`bool` as a
     |     sub-class of :class:`int`.
     |
     |  :Character code: ``'?'``
     |
     |  Method resolution order:
     |      bool
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __eq__(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.
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(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.
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class broadcast(builtins.object)
     |  Produce an object that mimics broadcasting.
     |
     |  Parameters
     |  ----------
     |  in1, in2, ... : array_like
     |      Input parameters.
     |
     |  Returns
     |  -------
     |  b : broadcast object
     |      Broadcast the input parameters against one another, and
     |      return an object that encapsulates the result.
     |      Amongst others, it has ``shape`` and ``nd`` properties, and
     |      may be used as an iterator.
     |
     |  See Also
     |  --------
     |  broadcast_arrays
     |  broadcast_to
     |  broadcast_shapes
     |
     |  Examples
     |  --------
     |
     |  Manually adding two vectors, using broadcasting:
     |
     |  >>> import numpy as np
     |  >>> x = np.array([[1], [2], [3]])
     |  >>> y = np.array([4, 5, 6])
     |  >>> b = np.broadcast(x, y)
     |
     |  >>> out = np.empty(b.shape)
     |  >>> out.flat = [u+v for (u,v) in b]
     |  >>> out
     |  array([[5.,  6.,  7.],
     |         [6.,  7.,  8.],
     |         [7.,  8.,  9.]])
     |
     |  Compare against built-in broadcasting:
     |
     |  >>> x + y
     |  array([[5, 6, 7],
     |         [6, 7, 8],
     |         [7, 8, 9]])
     |
     |  Methods defined here:
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __next__(self, /)
     |      Implement next(self).
     |
     |  reset(...)
     |      reset()
     |
     |      Reset the broadcasted result's iterator(s).
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      None
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.index
     |      0
     |      >>> next(b), next(b), next(b)
     |      ((1, 4), (2, 4), (3, 4))
     |      >>> b.index
     |      3
     |      >>> b.reset()
     |      >>> b.index
     |      0
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  index
     |      current index in broadcasted result
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.array([[1], [2], [3]])
     |      >>> y = np.array([4, 5, 6])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.index
     |      0
     |      >>> next(b), next(b), next(b)
     |      ((1, 4), (1, 5), (1, 6))
     |      >>> b.index
     |      3
     |
     |  iters
     |      tuple of iterators along ``self``'s "components."
     |
     |      Returns a tuple of `numpy.flatiter` objects, one for each "component"
     |      of ``self``.
     |
     |      See Also
     |      --------
     |      numpy.flatiter
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> row, col = b.iters
     |      >>> next(row), next(col)
     |      (1, 4)
     |
     |  nd
     |      Number of dimensions of broadcasted result. For code intended for NumPy
     |      1.12.0 and later the more consistent `ndim` is preferred.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.nd
     |      2
     |
     |  ndim
     |      Number of dimensions of broadcasted result. Alias for `nd`.
     |
     |      .. versionadded:: 1.12.0
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.ndim
     |      2
     |
     |  numiter
     |      Number of iterators possessed by the broadcasted result.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.numiter
     |      2
     |
     |  shape
     |      Shape of broadcasted result.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.shape
     |      (3, 3)
     |
     |  size
     |      Total size of broadcasted result.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> y = np.array([[4], [5], [6]])
     |      >>> b = np.broadcast(x, y)
     |      >>> b.size
     |      9

    class busdaycalendar(builtins.object)
     |  busdaycalendar(weekmask='1111100', holidays=None)
     |
     |  A business day calendar object that efficiently stores information
     |  defining valid days for the busday family of functions.
     |
     |  The default valid days are Monday through Friday ("business days").
     |  A busdaycalendar object can be specified with any set of weekly
     |  valid days, plus an optional "holiday" dates that always will be invalid.
     |
     |  Once a busdaycalendar object is created, the weekmask and holidays
     |  cannot be modified.
     |
     |  .. versionadded:: 1.7.0
     |
     |  Parameters
     |  ----------
     |  weekmask : str or array_like of bool, optional
     |      A seven-element array indicating which of Monday through Sunday are
     |      valid days. May be specified as a length-seven list or array, like
     |      [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
     |      like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
     |      weekdays, optionally separated by white space. Valid abbreviations
     |      are: Mon Tue Wed Thu Fri Sat Sun
     |  holidays : array_like of datetime64[D], optional
     |      An array of dates to consider as invalid dates, no matter which
     |      weekday they fall upon.  Holiday dates may be specified in any
     |      order, and NaT (not-a-time) dates are ignored.  This list is
     |      saved in a normalized form that is suited for fast calculations
     |      of valid days.
     |
     |  Returns
     |  -------
     |  out : busdaycalendar
     |      A business day calendar object containing the specified
     |      weekmask and holidays values.
     |
     |  See Also
     |  --------
     |  is_busday : Returns a boolean array indicating valid days.
     |  busday_offset : Applies an offset counted in valid days.
     |  busday_count : Counts how many valid days are in a half-open date range.
     |
     |  Attributes
     |  ----------
     |  weekmask : (copy) seven-element array of bool
     |  holidays : (copy) sorted array of datetime64[D]
     |
     |  Notes
     |  -----
     |  Once a busdaycalendar object is created, you cannot modify the
     |  weekmask or holidays.  The attributes return copies of internal data.
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> # Some important days in July
     |  ... bdd = np.busdaycalendar(
     |  ...             holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
     |  >>> # Default is Monday to Friday weekdays
     |  ... bdd.weekmask
     |  array([ True,  True,  True,  True,  True, False, False])
     |  >>> # Any holidays already on the weekend are removed
     |  ... bdd.holidays
     |  array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')
     |
     |  Methods defined here:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  holidays
     |      A copy of the holiday array indicating additional invalid days.
     |
     |  weekmask
     |      A copy of the seven-element boolean mask indicating valid days.

    byte = class int8(signedinteger)
     |  Signed integer type, compatible with C ``char``.
     |
     |  :Character code: ``'b'``
     |  :Canonical name: `numpy.byte`
     |  :Alias on this platform (win32 AMD64): `numpy.int8`: 8-bit signed integer (``-128`` to ``127``).
     |
     |  Method resolution order:
     |      int8
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int8.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int8(127).bit_count()
     |      7
     |      >>> np.int8(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class bytes_(builtins.bytes, character)
     |  A byte string.
     |
     |  When used in arrays, this type strips trailing null bytes.
     |
     |  :Character code: ``'S'``
     |
     |  Method resolution order:
     |      bytes_
     |      builtins.bytes
     |      character
     |      flexible
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.bytes:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __bytes__(self, /)
     |      Convert this value to exact type bytes.
     |
     |  __contains__(self, key, /)
     |      Return bool(key in self).
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __getnewargs__(...)
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*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(self, width, fillchar=b' ', /)
     |      Return a centered string of length width.
     |
     |      Padding is done using the specified fill character.
     |
     |  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(self, /, tabsize=8)
     |      Return a copy 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.
     |
     |  hex(...)
     |      Create a string of hexadecimal numbers from a bytes object.
     |
     |        sep
     |          An optional single character or byte to separate hex bytes.
     |        bytes_per_sep
     |          How many bytes between separators.  Positive values count from the
     |          right, negative values count from the left.
     |
     |      Example:
     |      >>> value = b'\xb9\x01\xef'
     |      >>> value.hex()
     |      'b901ef'
     |      >>> value.hex(':')
     |      'b9:01:ef'
     |      >>> value.hex(':', 2)
     |      'b9:01ef'
     |      >>> value.hex(':', -2)
     |      'b901:ef'
     |
     |  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.
     |
     |  isascii(...)
     |      B.isascii() -> bool
     |
     |      Return True if B is empty or all characters in B are ASCII,
     |      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(self, width, fillchar=b' ', /)
     |      Return a left-justified string of length width.
     |
     |      Padding is done using the specified fill character.
     |
     |  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.
     |
     |  removeprefix(self, prefix, /)
     |      Return a bytes object with the given prefix string removed if present.
     |
     |      If the bytes starts with the prefix string, return bytes[len(prefix):].
     |      Otherwise, return a copy of the original bytes.
     |
     |  removesuffix(self, suffix, /)
     |      Return a bytes object with the given suffix string removed if present.
     |
     |      If the bytes ends with the suffix string and that suffix is not empty,
     |      return bytes[:-len(prefix)].  Otherwise, return a copy of the original
     |      bytes.
     |
     |  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(self, width, fillchar=b' ', /)
     |      Return a right-justified string of length width.
     |
     |      Padding is done using the specified fill character.
     |
     |  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(self, width, /)
     |      Pad a numeric string with zeros on the left, to fill a field of the given width.
     |
     |      The original string is never truncated.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.bytes:
     |
     |  fromhex(string, /)
     |      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'.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.bytes:
     |
     |  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.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(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.
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    cdouble = class complex128(complexfloating, builtins.complex)
     |  cdouble(real=0, imag=0)
     |
     |  Complex number type composed of two double-precision floating-point
     |  numbers, compatible with Python :class:`complex`.
     |
     |  :Character code: ``'D'``
     |  :Canonical name: `numpy.cdouble`
     |  :Alias on this platform (win32 AMD64): `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers.
     |
     |  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.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from complexfloating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.complex:
     |
     |  __complex__(self, /)
     |      Convert this value to exact type complex.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)

    class character(flexible)
     |  Abstract base class of all character string scalar types.
     |
     |  Method resolution order:
     |      character
     |      flexible
     |      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__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    class clongdouble(complexfloating)
     |  Complex number type composed of two extended-precision floating-point
     |  numbers.
     |
     |  :Character code: ``'G'``
     |
     |  Method resolution order:
     |      clongdouble
     |      complexfloating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from complexfloating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class complex128(complexfloating, builtins.complex)
     |  complex128(real=0, imag=0)
     |
     |  Complex number type composed of two double-precision floating-point
     |  numbers, compatible with Python :class:`complex`.
     |
     |  :Character code: ``'D'``
     |  :Canonical name: `numpy.cdouble`
     |  :Alias on this platform (win32 AMD64): `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers.
     |
     |  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.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from complexfloating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.complex:
     |
     |  __complex__(self, /)
     |      Convert this value to exact type complex.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)

    class complex64(complexfloating)
     |  Complex number type composed of two single-precision floating-point
     |  numbers.
     |
     |  :Character code: ``'F'``
     |  :Canonical name: `numpy.csingle`
     |  :Alias on this platform (win32 AMD64): `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers.
     |
     |  Method resolution order:
     |      complex64
     |      complexfloating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from complexfloating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class complexfloating(inexact)
     |  Abstract base class of all complex number scalar types that are made up of
     |  floating-point numbers.
     |
     |  Method resolution order:
     |      complexfloating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from number:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    csingle = class complex64(complexfloating)
     |  Complex number type composed of two single-precision floating-point
     |  numbers.
     |
     |  :Character code: ``'F'``
     |  :Canonical name: `numpy.csingle`
     |  :Alias on this platform (win32 AMD64): `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers.
     |
     |  Method resolution order:
     |      complex64
     |      complexfloating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from complexfloating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class datetime64(generic)
     |  If created from a 64-bit integer, it represents an offset from
     |  ``1970-01-01T00:00:00``.
     |  If created from string, the string can be in ISO 8601 date
     |  or datetime format.
     |
     |  When parsing a string to create a datetime object, if the string contains
     |  a trailing timezone (A 'Z' or a timezone offset), the timezone will be
     |  dropped and a User Warning is given.
     |
     |  Datetime64 objects should be considered to be UTC and therefore have an
     |  offset of +0000.
     |
     |  >>> np.datetime64(10, 'Y')
     |  np.datetime64('1980')
     |  >>> np.datetime64('1980', 'Y')
     |  np.datetime64('1980')
     |  >>> np.datetime64(10, 'D')
     |  np.datetime64('1970-01-11')
     |
     |  See :ref:`arrays.datetime` for more information.
     |
     |  :Character code: ``'M'``
     |
     |  Method resolution order:
     |      datetime64
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    double = class float64(floating, builtins.float)
     |  double(x=0, /)
     |
     |  Double-precision floating-point number type, compatible with Python
     |  :class:`float` and C ``double``.
     |
     |  :Character code: ``'d'``
     |  :Canonical name: `numpy.double`
     |  :Alias on this platform (win32 AMD64): `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.
     |
     |  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.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      double.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.double(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.double(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.double(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      double.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.double(-2.0).is_integer()
     |      True
     |      >>> np.double(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.float:
     |
     |  __ceil__(self, /)
     |      Return the ceiling as an Integral.
     |
     |  __floor__(self, /)
     |      Return the floor as an Integral.
     |
     |  __getnewargs__(self, /)
     |
     |  __trunc__(self, /)
     |      Return the Integral closest to x between 0 and x.
     |
     |  hex(self, /)
     |      Return a hexadecimal representation of a floating-point number.
     |
     |      >>> (-0.1).hex()
     |      '-0x1.999999999999ap-4'
     |      >>> 3.14159.hex()
     |      '0x1.921f9f01b866ep+1'
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.float:
     |
     |  __getformat__(typestr, /)
     |      You probably don't want to use this function.
     |
     |        typestr
     |          Must be 'double' or 'float'.
     |
     |      It exists mainly to be used in Python's test suite.
     |
     |      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.
     |
     |  fromhex(string, /)
     |      Create a floating-point number from a hexadecimal string.
     |
     |      >>> float.fromhex('0x1.ffffp10')
     |      2047.984375
     |      >>> float.fromhex('-0x1p-1074')
     |      -5e-324

    class dtype(builtins.object)
     |  dtype(dtype, align=False, copy=False, [metadata])
     |
     |  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
     |  ----------
     |  dtype
     |      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.
     |  metadata : dict, optional
     |      An optional dictionary with dtype metadata.
     |
     |  See also
     |  --------
     |  result_type
     |
     |  Examples
     |  --------
     |  Using array-scalar type:
     |
     |  >>> import numpy as np
     |  >>> 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.uint64), ('f2', np.int32)])
     |  dtype([('f1', '<u8'), ('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',(np.int64,3)),('world',np.void,10)])
     |  dtype([('hello', '<i8', (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((numpy.int16, [('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, /)
     |      True if self else False
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __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
     |          * {'<', 'little'} - little endian
     |          * {'>', 'big'} - big endian
     |          * {'=', 'native'} - native order
     |          * {'|', 'I'} - ignore (no change to byte order)
     |
     |      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 = '<' if sys_is_le else '>'
     |      >>> swapped_code = '>' if sys_is_le else '<'
     |      >>> import numpy as np
     |      >>> 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
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.dtype` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.dtype` type.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |
     |      >>> np.dtype[np.int64]
     |      numpy.dtype[numpy.int64]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  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.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.dtype('i4')
     |      >>> x.alignment
     |      4
     |
     |      >>> x = np.dtype(float)
     |      >>> x.alignment
     |      8
     |
     |  base
     |      Returns dtype for the base element of the subarrays,
     |      regardless of their dimension or shape.
     |
     |      See Also
     |      --------
     |      dtype.subdtype
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = numpy.dtype('8f')
     |      >>> x.base
     |      dtype('float32')
     |
     |      >>> x =  numpy.dtype('i2')
     |      >>> x.base
     |      dtype('int16')
     |
     |  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
     |      --------
     |
     |      >>> import numpy as np
     |      >>> 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 = '<' if sys_is_le else '>'
     |      >>> swapped_code = '>' if sys_is_le else '<'
     |      >>> 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.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.dtype(float)
     |      >>> x.char
     |      'd'
     |
     |  descr
     |      `__array_interface__` description of the data-type.
     |
     |      The format is that required by the 'descr' key in the
     |      `__array_interface__` attribute.
     |
     |      Warning: This attribute exists specifically for `__array_interface__`,
     |      and passing it directly to `numpy.dtype` will not accurately reconstruct
     |      some dtypes (e.g., scalar and subarray dtypes).
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.dtype(float)
     |      >>> x.descr
     |      [('', '<f8')]
     |
     |      >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
     |      >>> dt.descr
     |      [('name', '<U16'), ('grades', '<f8', (2,))]
     |
     |  fields
     |      Dictionary of named fields defined for this data type, or ``None``.
     |
     |      The dictionary is indexed by keys that are the names of the fields.
     |      Each entry in the dictionary is a tuple fully describing the field::
     |
     |        (dtype, offset[, title])
     |
     |      Offset is limited to C int, which is signed and usually 32 bits.
     |      If present, the optional title can be any object (if it is a string
     |      or unicode then it will also be a key in the fields dictionary,
     |      otherwise it's meta-data). Notice also that the first two elements
     |      of the tuple can be passed directly as arguments to the
     |      ``ndarray.getfield`` and ``ndarray.setfield`` methods.
     |
     |      See Also
     |      --------
     |      ndarray.getfield, ndarray.setfield
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> 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.
     |
     |      The following example demonstrates that operations on this particular
     |      dtype requires Python C-API.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
     |      >>> x.flags
     |      16
     |      >>> np._core.multiarray.NEEDS_PYAPI
     |      16
     |
     |  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
     |      --------
     |
     |      >>> import numpy as np
     |      >>> 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.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> arr = np.array([[1, 2], [3, 4]])
     |      >>> arr.dtype
     |      dtype('int64')
     |      >>> arr.itemsize
     |      8
     |
     |      >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
     |      >>> dt.itemsize
     |      80
     |
     |  kind
     |      A character code (one of 'biufcmMOSUV') identifying the general kind of data.
     |
     |      =  ======================
     |      b  boolean
     |      i  signed integer
     |      u  unsigned integer
     |      f  floating-point
     |      c  complex floating-point
     |      m  timedelta
     |      M  datetime
     |      O  object
     |      S  (byte-)string
     |      U  Unicode
     |      V  void
     |      =  ======================
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> dt = np.dtype('i4')
     |      >>> dt.kind
     |      'i'
     |      >>> dt = np.dtype('f8')
     |      >>> dt.kind
     |      'f'
     |      >>> dt = np.dtype([('field1', 'f8')])
     |      >>> dt.kind
     |      'V'
     |
     |  metadata
     |      Either ``None`` or a readonly dictionary of metadata (mappingproxy).
     |
     |      The metadata field can be set using any dictionary at data-type
     |      creation. NumPy currently has no uniform approach to propagating
     |      metadata; although some array operations preserve it, there is no
     |      guarantee that others will.
     |
     |      .. warning::
     |
     |          Although used in certain projects, this feature was long undocumented
     |          and is not well supported. Some aspects of metadata propagation
     |          are expected to change in the future.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> dt = np.dtype(float, metadata={"key": "value"})
     |      >>> dt.metadata["key"]
     |      'value'
     |      >>> arr = np.array([1, 2, 3], dtype=dt)
     |      >>> arr.dtype.metadata
     |      mappingproxy({'key': 'value'})
     |
     |      Adding arrays with identical datatypes currently preserves the metadata:
     |
     |      >>> (arr + arr).dtype.metadata
     |      mappingproxy({'key': 'value'})
     |
     |      But if the arrays have different dtype metadata, the metadata may be
     |      dropped:
     |
     |      >>> dt2 = np.dtype(float, metadata={"key2": "value2"})
     |      >>> arr2 = np.array([3, 2, 1], dtype=dt2)
     |      >>> (arr + arr2).dtype.metadata is None
     |      True  # The metadata field is cleared so None is returned
     |
     |  name
     |      A bit-width name for this data-type.
     |
     |      Un-sized flexible data-type objects do not have this attribute.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> x = np.dtype(float)
     |      >>> x.name
     |      'float64'
     |      >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
     |      >>> x.name
     |      'void640'
     |
     |  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
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.dtype(float)
     |      >>> x.ndim
     |      0
     |
     |      >>> x = np.dtype((float, 8))
     |      >>> x.ndim
     |      1
     |
     |      >>> x = np.dtype(('i4', (3, 4)))
     |      >>> x.ndim
     |      2
     |
     |  num
     |      A unique number for each of the 21 different built-in types.
     |
     |      These are roughly ordered from least-to-most precision.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> dt = np.dtype(str)
     |      >>> dt.num
     |      19
     |
     |      >>> dt = np.dtype(float)
     |      >>> dt.num
     |      12
     |
     |  shape
     |      Shape tuple of the sub-array if this data type describes a sub-array,
     |      and ``()`` otherwise.
     |
     |      Examples
     |      --------
     |
     |      >>> import numpy as np
     |      >>> dt = np.dtype(('i4', 4))
     |      >>> dt.shape
     |      (4,)
     |
     |      >>> dt = np.dtype(('i4', (2, 3)))
     |      >>> dt.shape
     |      (2, 3)
     |
     |  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.
     |
     |      See Also
     |      --------
     |      dtype.base
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = numpy.dtype('8f')
     |      >>> x.subdtype
     |      (dtype('float32'), (8,))
     |
     |      >>> x =  numpy.dtype('i2')
     |      >>> x.subdtype
     |      >>>
     |
     |  type

    class errstate(builtins.object)
     |  errstate(*, call=<numpy._core._ufunc_config._unspecified object at 0x0000011F9424BB30>, all=None, divide=None, over=None, under=None, invalid=None)
     |
     |  errstate(**kwargs)
     |
     |  Context manager for floating-point error handling.
     |
     |  Using an instance of `errstate` as a context manager allows statements in
     |  that context to execute with a known error handling behavior. Upon entering
     |  the context the error handling is set with `seterr` and `seterrcall`, and
     |  upon exiting it is reset to what it was before.
     |
     |  ..  versionchanged:: 1.17.0
     |      `errstate` is also usable as a function decorator, saving
     |      a level of indentation if an entire function is wrapped.
     |
     |  .. versionchanged:: 2.0
     |      `errstate` is now fully thread and asyncio safe, but may not be
     |      entered more than once.
     |      It is not safe to decorate async functions using ``errstate``.
     |
     |  Parameters
     |  ----------
     |  kwargs : {divide, over, under, invalid}
     |      Keyword arguments. The valid keywords are the possible floating-point
     |      exceptions. Each keyword should have a string value that defines the
     |      treatment for the particular error. Possible values are
     |      {'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
     |
     |  See Also
     |  --------
     |  seterr, geterr, seterrcall, geterrcall
     |
     |  Notes
     |  -----
     |  For complete documentation of the types of floating-point exceptions and
     |  treatment options, see `seterr`.
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> olderr = np.seterr(all='ignore')  # Set error handling to known state.
     |
     |  >>> np.arange(3) / 0.
     |  array([nan, inf, inf])
     |  >>> with np.errstate(divide='ignore'):
     |  ...     np.arange(3) / 0.
     |  array([nan, inf, inf])
     |
     |  >>> np.sqrt(-1)
     |  np.float64(nan)
     |  >>> with np.errstate(invalid='raise'):
     |  ...     np.sqrt(-1)
     |  Traceback (most recent call last):
     |    File "<stdin>", line 2, in <module>
     |  FloatingPointError: invalid value encountered in sqrt
     |
     |  Outside the context the error handling behavior has not changed:
     |
     |  >>> np.geterr()
     |  {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
     |  >>> olderr = np.seterr(**olderr)  # restore original state
     |
     |  Methods defined here:
     |
     |  __call__(self, func) from numpy._core._ufunc_config.errstate
     |      Call self as a function.
     |
     |  __enter__(self) from numpy._core._ufunc_config.errstate
     |
     |  __exit__(self, *exc_info) from numpy._core._ufunc_config.errstate
     |
     |  __init__(self, *, call=<numpy._core._ufunc_config._unspecified object at 0x0000011F9424BB30>, all=None, divide=None, over=None, under=None, invalid=None) from numpy._core._ufunc_config.errstate
     |      Initialize self.  See help(type(self)) for accurate signature.

    class finfo(builtins.object)
     |  finfo(dtype)
     |
     |  finfo(dtype)
     |
     |  Machine limits for floating point types.
     |
     |  Attributes
     |  ----------
     |  bits : int
     |      The number of bits occupied by the type.
     |  dtype : dtype
     |      Returns the dtype for which `finfo` returns information. For complex
     |      input, the returned dtype is the associated ``float*`` dtype for its
     |      real and complex components.
     |  eps : float
     |      The difference between 1.0 and the next smallest representable float
     |      larger than 1.0. For example, for 64-bit binary floats in the IEEE-754
     |      standard, ``eps = 2**-52``, approximately 2.22e-16.
     |  epsneg : float
     |      The difference between 1.0 and the next smallest representable float
     |      less than 1.0. For example, for 64-bit binary floats in the IEEE-754
     |      standard, ``epsneg = 2**-53``, approximately 1.11e-16.
     |  iexp : int
     |      The number of bits in the exponent portion of the floating point
     |      representation.
     |  machep : int
     |      The exponent that yields `eps`.
     |  max : floating point number of the appropriate type
     |      The largest representable number.
     |  maxexp : int
     |      The smallest positive power of the base (2) that causes overflow.
     |  min : floating point number of the appropriate type
     |      The smallest representable number, typically ``-max``.
     |  minexp : int
     |      The most negative power of the base (2) consistent with there
     |      being no leading 0's in the mantissa.
     |  negep : int
     |      The exponent that yields `epsneg`.
     |  nexp : int
     |      The number of bits in the exponent including its sign and bias.
     |  nmant : int
     |      The number of bits in the mantissa.
     |  precision : int
     |      The approximate number of decimal digits to which this kind of
     |      float is precise.
     |  resolution : floating point number of the appropriate type
     |      The approximate decimal resolution of this type, i.e.,
     |      ``10**-precision``.
     |  tiny : float
     |      An alias for `smallest_normal`, kept for backwards compatibility.
     |  smallest_normal : float
     |      The smallest positive floating point number with 1 as leading bit in
     |      the mantissa following IEEE-754 (see Notes).
     |  smallest_subnormal : float
     |      The smallest positive floating point number with 0 as leading bit in
     |      the mantissa following IEEE-754.
     |
     |  Parameters
     |  ----------
     |  dtype : float, dtype, or instance
     |      Kind of floating point or complex floating point
     |      data-type about which to get information.
     |
     |  See Also
     |  --------
     |  iinfo : The equivalent for integer data types.
     |  spacing : The distance between a value and the nearest adjacent number
     |  nextafter : The next floating point value after x1 towards x2
     |
     |  Notes
     |  -----
     |  For developers of NumPy: do not instantiate this at the module level.
     |  The initial calculation of these parameters is expensive and negatively
     |  impacts import times.  These objects are cached, so calling ``finfo()``
     |  repeatedly inside your functions is not a problem.
     |
     |  Note that ``smallest_normal`` is not actually the smallest positive
     |  representable value in a NumPy floating point type. As in the IEEE-754
     |  standard [1]_, NumPy floating point types make use of subnormal numbers to
     |  fill the gap between 0 and ``smallest_normal``. However, subnormal numbers
     |  may have significantly reduced precision [2]_.
     |
     |  This function can also be used for complex data types as well. If used,
     |  the output will be the same as the corresponding real float type
     |  (e.g. numpy.finfo(numpy.csingle) is the same as numpy.finfo(numpy.single)).
     |  However, the output is true for the real and imaginary components.
     |
     |  References
     |  ----------
     |  .. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,
     |         pp.1-70, 2008, https://doi.org/10.1109/IEEESTD.2008.4610935
     |  .. [2] Wikipedia, "Denormal Numbers",
     |         https://en.wikipedia.org/wiki/Denormal_number
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> np.finfo(np.float64).dtype
     |  dtype('float64')
     |  >>> np.finfo(np.complex64).dtype
     |  dtype('float32')
     |
     |  Methods defined here:
     |
     |  __repr__(self) from numpy._core.getlimits.finfo
     |      Return repr(self).
     |
     |  __str__(self) from numpy._core.getlimits.finfo
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(cls, dtype) from numpy._core.getlimits.finfo
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  smallest_normal
     |      Return the value for the smallest normal.
     |
     |      Returns
     |      -------
     |      smallest_normal : float
     |          Value for the smallest normal.
     |
     |      Warns
     |      -----
     |      UserWarning
     |          If the calculated value for the smallest normal is requested for
     |          double-double.
     |
     |  tiny
     |      Return the value for tiny, alias of smallest_normal.
     |
     |      Returns
     |      -------
     |      tiny : float
     |          Value for the smallest normal, alias of smallest_normal.
     |
     |      Warns
     |      -----
     |      UserWarning
     |          If the calculated value for the smallest normal is requested for
     |          double-double.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class flatiter(builtins.object)
     |  Flat iterator object to iterate over arrays.
     |
     |  A `flatiter` iterator is returned by ``x.flat`` for any array `x`.
     |  It allows iterating over the array as if it were a 1-D array,
     |  either in a for-loop or by calling its `next` method.
     |
     |  Iteration is done in row-major, C-style order (the last
     |  index varying the fastest). The iterator can also be indexed using
     |  basic slicing or advanced indexing.
     |
     |  See Also
     |  --------
     |  ndarray.flat : Return a flat iterator over an array.
     |  ndarray.flatten : Returns a flattened copy of an array.
     |
     |  Notes
     |  -----
     |  A `flatiter` iterator can not be constructed directly from Python code
     |  by calling the `flatiter` constructor.
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> x = np.arange(6).reshape(2, 3)
     |  >>> fl = x.flat
     |  >>> type(fl)
     |  <class 'numpy.flatiter'>
     |  >>> for item in fl:
     |  ...     print(item)
     |  ...
     |  0
     |  1
     |  2
     |  3
     |  4
     |  5
     |
     |  >>> fl[2:4]
     |  array([2, 3])
     |
     |  Methods defined here:
     |
     |  __array__(...)
     |      __array__(type=None) Get array from iterator
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __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.
     |
     |  __next__(self, /)
     |      Implement next(self).
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  copy(...)
     |      copy()
     |
     |      Get a copy of the iterator as a 1-D array.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.arange(6).reshape(2, 3)
     |      >>> x
     |      array([[0, 1, 2],
     |             [3, 4, 5]])
     |      >>> fl = x.flat
     |      >>> fl.copy()
     |      array([0, 1, 2, 3, 4, 5])
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  base
     |      A reference to the array that is iterated over.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.arange(5)
     |      >>> fl = x.flat
     |      >>> fl.base is x
     |      True
     |
     |  coords
     |      An N-dimensional tuple of current coordinates.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.arange(6).reshape(2, 3)
     |      >>> fl = x.flat
     |      >>> fl.coords
     |      (0, 0)
     |      >>> next(fl)
     |      0
     |      >>> fl.coords
     |      (0, 1)
     |
     |  index
     |      Current flat index into the array.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.arange(6).reshape(2, 3)
     |      >>> fl = x.flat
     |      >>> fl.index
     |      0
     |      >>> next(fl)
     |      0
     |      >>> fl.index
     |      1
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

    class flexible(generic)
     |  Abstract base class of all scalar types without predefined length.
     |  The actual size of these types depends on the specific `numpy.dtype`
     |  instantiation.
     |
     |  Method resolution order:
     |      flexible
     |      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__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    class float16(floating)
     |  Half-precision floating-point number type.
     |
     |  :Character code: ``'e'``
     |  :Canonical name: `numpy.half`
     |  :Alias on this platform (win32 AMD64): `numpy.float16`: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.
     |
     |  Method resolution order:
     |      float16
     |      floating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      half.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.half(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.half(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.half(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      half.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.half(-2.0).is_integer()
     |      True
     |      >>> np.half(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class float32(floating)
     |  Single-precision floating-point number type, compatible with C ``float``.
     |
     |  :Character code: ``'f'``
     |  :Canonical name: `numpy.single`
     |  :Alias on this platform (win32 AMD64): `numpy.float32`: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.
     |
     |  Method resolution order:
     |      float32
     |      floating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      single.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.single(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.single(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.single(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      single.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.single(-2.0).is_integer()
     |      True
     |      >>> np.single(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class float64(floating, builtins.float)
     |  float64(x=0, /)
     |
     |  Double-precision floating-point number type, compatible with Python
     |  :class:`float` and C ``double``.
     |
     |  :Character code: ``'d'``
     |  :Canonical name: `numpy.double`
     |  :Alias on this platform (win32 AMD64): `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.
     |
     |  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.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      double.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.double(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.double(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.double(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      double.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.double(-2.0).is_integer()
     |      True
     |      >>> np.double(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.float:
     |
     |  __ceil__(self, /)
     |      Return the ceiling as an Integral.
     |
     |  __floor__(self, /)
     |      Return the floor as an Integral.
     |
     |  __getnewargs__(self, /)
     |
     |  __trunc__(self, /)
     |      Return the Integral closest to x between 0 and x.
     |
     |  hex(self, /)
     |      Return a hexadecimal representation of a floating-point number.
     |
     |      >>> (-0.1).hex()
     |      '-0x1.999999999999ap-4'
     |      >>> 3.14159.hex()
     |      '0x1.921f9f01b866ep+1'
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.float:
     |
     |  __getformat__(typestr, /)
     |      You probably don't want to use this function.
     |
     |        typestr
     |          Must be 'double' or 'float'.
     |
     |      It exists mainly to be used in Python's test suite.
     |
     |      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.
     |
     |  fromhex(string, /)
     |      Create a floating-point number from a hexadecimal string.
     |
     |      >>> float.fromhex('0x1.ffffp10')
     |      2047.984375
     |      >>> float.fromhex('-0x1p-1074')
     |      -5e-324

    class floating(inexact)
     |  Abstract base class of all floating-point scalar types.
     |
     |  Method resolution order:
     |      floating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from number:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    class generic(builtins.object)
     |  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.
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

    half = class float16(floating)
     |  Half-precision floating-point number type.
     |
     |  :Character code: ``'e'``
     |  :Canonical name: `numpy.half`
     |  :Alias on this platform (win32 AMD64): `numpy.float16`: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.
     |
     |  Method resolution order:
     |      float16
     |      floating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      half.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.half(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.half(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.half(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      half.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.half(-2.0).is_integer()
     |      True
     |      >>> np.half(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class iinfo(builtins.object)
     |  iinfo(int_type)
     |
     |  iinfo(type)
     |
     |  Machine limits for integer types.
     |
     |  Attributes
     |  ----------
     |  bits : int
     |      The number of bits occupied by the type.
     |  dtype : dtype
     |      Returns the dtype for which `iinfo` returns information.
     |  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:
     |
     |  >>> import numpy as np
     |  >>> 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) from numpy._core.getlimits.iinfo
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) from numpy._core.getlimits.iinfo
     |      Return repr(self).
     |
     |  __str__(self) from numpy._core.getlimits.iinfo
     |      String representation.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  max
     |      Maximum value of given dtype.
     |
     |  min
     |      Minimum value of given dtype.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class inexact(number)
     |  Abstract base class of all numeric scalar types with a (potentially)
     |  inexact representation of the values in its range, such as
     |  floating-point numbers.
     |
     |  Method resolution order:
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Class methods inherited from number:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    class int16(signedinteger)
     |  Signed integer type, compatible with C ``short``.
     |
     |  :Character code: ``'h'``
     |  :Canonical name: `numpy.short`
     |  :Alias on this platform (win32 AMD64): `numpy.int16`: 16-bit signed integer (``-32_768`` to ``32_767``).
     |
     |  Method resolution order:
     |      int16
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int16.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int16(127).bit_count()
     |      7
     |      >>> np.int16(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class int32(signedinteger)
     |  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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int32.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int32(127).bit_count()
     |      7
     |      >>> np.int32(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class int64(signedinteger)
     |  Default signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'q'``
     |  :Canonical name: `numpy.int_`
     |  :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
     |  :Alias on this platform (win32 AMD64): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``.
     |
     |  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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int64(127).bit_count()
     |      7
     |      >>> np.int64(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class int8(signedinteger)
     |  Signed integer type, compatible with C ``char``.
     |
     |  :Character code: ``'b'``
     |  :Canonical name: `numpy.byte`
     |  :Alias on this platform (win32 AMD64): `numpy.int8`: 8-bit signed integer (``-128`` to ``127``).
     |
     |  Method resolution order:
     |      int8
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int8.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int8(127).bit_count()
     |      7
     |      >>> np.int8(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    int_ = class int64(signedinteger)
     |  Default signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'q'``
     |  :Canonical name: `numpy.int_`
     |  :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
     |  :Alias on this platform (win32 AMD64): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``.
     |
     |  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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int64(127).bit_count()
     |      7
     |      >>> np.int64(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class intc(signedinteger)
     |  Signed integer type, compatible with C ``int``.
     |
     |  :Character code: ``'i'``
     |
     |  Method resolution order:
     |      intc
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class integer(number)
     |  Abstract base class of all integer scalar types.
     |
     |  Method resolution order:
     |      integer
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from number:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    intp = class int64(signedinteger)
     |  Default signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'q'``
     |  :Canonical name: `numpy.int_`
     |  :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
     |  :Alias on this platform (win32 AMD64): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``.
     |
     |  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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int64(127).bit_count()
     |      7
     |      >>> np.int64(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    long = class int32(signedinteger)
     |  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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int32.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int32(127).bit_count()
     |      7
     |      >>> np.int32(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class longdouble(floating)
     |  Extended-precision floating-point number type, compatible with C
     |  ``long double`` but not necessarily with IEEE 754 quadruple-precision.
     |
     |  :Character code: ``'g'``
     |
     |  Method resolution order:
     |      longdouble
     |      floating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      longdouble.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.longdouble(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.longdouble(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.longdouble(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      longdouble.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.longdouble(-2.0).is_integer()
     |      True
     |      >>> np.longdouble(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    longlong = class int64(signedinteger)
     |  Default signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'q'``
     |  :Canonical name: `numpy.int_`
     |  :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
     |  :Alias on this platform (win32 AMD64): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``.
     |
     |  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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int64(127).bit_count()
     |      7
     |      >>> np.int64(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class matrix(ndarray)
     |  matrix(data, dtype=None, copy=True)
     |
     |  matrix(data, dtype=None, copy=True)
     |
     |  Returns a matrix from an array-like object, or from a string of data.
     |
     |  A matrix is a specialized 2-D array that retains its 2-D nature
     |  through operations.  It has certain special operators, such as ``*``
     |  (matrix multiplication) and ``**`` (matrix power).
     |
     |  .. note:: It is no longer recommended to use this class, even for linear
     |            algebra. Instead use regular arrays. The class may be removed
     |            in the future.
     |
     |  Parameters
     |  ----------
     |  data : array_like or string
     |     If `data` is a string, it is interpreted as a matrix with commas
     |     or spaces separating columns, and semicolons separating rows.
     |  dtype : data-type
     |     Data-type of the output matrix.
     |  copy : bool
     |     If `data` is already an `ndarray`, then this flag determines
     |     whether the data is copied (the default), or whether a view is
     |     constructed.
     |
     |  See Also
     |  --------
     |  array
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> a = np.matrix('1 2; 3 4')
     |  >>> a
     |  matrix([[1, 2],
     |          [3, 4]])
     |
     |  >>> np.matrix([[1, 2], [3, 4]])
     |  matrix([[1, 2],
     |          [3, 4]])
     |
     |  Method resolution order:
     |      matrix
     |      ndarray
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __array_finalize__(self, obj) from numpy.matrixlib.defmatrix.matrix
     |      a.__array_finalize__(obj, /)
     |
     |      Present so subclasses can call super. Does nothing.
     |
     |  __getitem__(self, index) from numpy.matrixlib.defmatrix.matrix
     |      Return self[key].
     |
     |  __imul__(self, other) from numpy.matrixlib.defmatrix.matrix
     |      Return self*=value.
     |
     |  __ipow__(self, other) from numpy.matrixlib.defmatrix.matrix
     |      Return self**=value.
     |
     |  __mul__(self, other) from numpy.matrixlib.defmatrix.matrix
     |      Return self*value.
     |
     |  __pow__(self, other) from numpy.matrixlib.defmatrix.matrix
     |      Return pow(self, value, mod).
     |
     |  __rmul__(self, other) from numpy.matrixlib.defmatrix.matrix
     |      Return value*self.
     |
     |  __rpow__(self, other) from numpy.matrixlib.defmatrix.matrix
     |      Return pow(value, self, mod).
     |
     |  all(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Test whether all matrix elements along a given axis evaluate to True.
     |
     |      Parameters
     |      ----------
     |      See `numpy.all` for complete descriptions
     |
     |      See Also
     |      --------
     |      numpy.all
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.all`, but it returns a `matrix` object.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> y = x[0]; y
     |      matrix([[0, 1, 2, 3]])
     |      >>> (x == y)
     |      matrix([[ True,  True,  True,  True],
     |              [False, False, False, False],
     |              [False, False, False, False]])
     |      >>> (x == y).all()
     |      False
     |      >>> (x == y).all(0)
     |      matrix([[False, False, False, False]])
     |      >>> (x == y).all(1)
     |      matrix([[ True],
     |              [False],
     |              [False]])
     |
     |  any(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Test whether any array element along a given axis evaluates to True.
     |
     |      Refer to `numpy.any` for full documentation.
     |
     |      Parameters
     |      ----------
     |      axis : int, optional
     |          Axis along which logical OR is performed
     |      out : ndarray, optional
     |          Output to existing array instead of creating new one, must have
     |          same shape as expected output
     |
     |      Returns
     |      -------
     |          any : bool, ndarray
     |              Returns a single bool if `axis` is ``None``; otherwise,
     |              returns `ndarray`
     |
     |  argmax(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Indexes of the maximum values along an axis.
     |
     |      Return the indexes of the first occurrences of the maximum values
     |      along the specified axis.  If axis is None, the index is for the
     |      flattened matrix.
     |
     |      Parameters
     |      ----------
     |      See `numpy.argmax` for complete descriptions
     |
     |      See Also
     |      --------
     |      numpy.argmax
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.argmax`, but returns a `matrix` object
     |      where `ndarray.argmax` would return an `ndarray`.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.argmax()
     |      11
     |      >>> x.argmax(0)
     |      matrix([[2, 2, 2, 2]])
     |      >>> x.argmax(1)
     |      matrix([[3],
     |              [3],
     |              [3]])
     |
     |  argmin(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Indexes of the minimum values along an axis.
     |
     |      Return the indexes of the first occurrences of the minimum values
     |      along the specified axis.  If axis is None, the index is for the
     |      flattened matrix.
     |
     |      Parameters
     |      ----------
     |      See `numpy.argmin` for complete descriptions.
     |
     |      See Also
     |      --------
     |      numpy.argmin
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.argmin`, but returns a `matrix` object
     |      where `ndarray.argmin` would return an `ndarray`.
     |
     |      Examples
     |      --------
     |      >>> x = -np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[  0,  -1,  -2,  -3],
     |              [ -4,  -5,  -6,  -7],
     |              [ -8,  -9, -10, -11]])
     |      >>> x.argmin()
     |      11
     |      >>> x.argmin(0)
     |      matrix([[2, 2, 2, 2]])
     |      >>> x.argmin(1)
     |      matrix([[3],
     |              [3],
     |              [3]])
     |
     |  flatten(self, order='C') from numpy.matrixlib.defmatrix.matrix
     |      Return a flattened copy of the matrix.
     |
     |      All `N` elements of the matrix are placed into a single row.
     |
     |      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 `m` is Fortran *contiguous* in
     |          memory, row-major order otherwise. 'K' means to flatten `m` in
     |          the order the elements occur in memory. The default is 'C'.
     |
     |      Returns
     |      -------
     |      y : matrix
     |          A copy of the matrix, flattened to a `(1, N)` matrix where `N`
     |          is the number of elements in the original matrix.
     |
     |      See Also
     |      --------
     |      ravel : Return a flattened array.
     |      flat : A 1-D flat iterator over the matrix.
     |
     |      Examples
     |      --------
     |      >>> m = np.matrix([[1,2], [3,4]])
     |      >>> m.flatten()
     |      matrix([[1, 2, 3, 4]])
     |      >>> m.flatten('F')
     |      matrix([[1, 3, 2, 4]])
     |
     |  getA = A(self) from numpy.matrixlib.defmatrix.matrix
     |      Return `self` as an `ndarray` object.
     |
     |      Equivalent to ``np.asarray(self)``.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : ndarray
     |          `self` as an `ndarray`
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.getA()
     |      array([[ 0,  1,  2,  3],
     |             [ 4,  5,  6,  7],
     |             [ 8,  9, 10, 11]])
     |
     |  getA1 = A1(self) from numpy.matrixlib.defmatrix.matrix
     |      Return `self` as a flattened `ndarray`.
     |
     |      Equivalent to ``np.asarray(x).ravel()``
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : ndarray
     |          `self`, 1-D, as an `ndarray`
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.getA1()
     |      array([ 0,  1,  2, ...,  9, 10, 11])
     |
     |  getH = H(self) from numpy.matrixlib.defmatrix.matrix
     |      Returns the (complex) conjugate transpose of `self`.
     |
     |      Equivalent to ``np.transpose(self)`` if `self` is real-valued.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : matrix object
     |          complex conjugate transpose of `self`
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4)))
     |      >>> z = x - 1j*x; z
     |      matrix([[  0. +0.j,   1. -1.j,   2. -2.j,   3. -3.j],
     |              [  4. -4.j,   5. -5.j,   6. -6.j,   7. -7.j],
     |              [  8. -8.j,   9. -9.j,  10.-10.j,  11.-11.j]])
     |      >>> z.getH()
     |      matrix([[ 0. -0.j,  4. +4.j,  8. +8.j],
     |              [ 1. +1.j,  5. +5.j,  9. +9.j],
     |              [ 2. +2.j,  6. +6.j, 10.+10.j],
     |              [ 3. +3.j,  7. +7.j, 11.+11.j]])
     |
     |  getI = I(self) from numpy.matrixlib.defmatrix.matrix
     |      Returns the (multiplicative) inverse of invertible `self`.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : matrix object
     |          If `self` is non-singular, `ret` is such that ``ret * self`` ==
     |          ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return
     |          ``True``.
     |
     |      Raises
     |      ------
     |      numpy.linalg.LinAlgError: Singular matrix
     |          If `self` is singular.
     |
     |      See Also
     |      --------
     |      linalg.inv
     |
     |      Examples
     |      --------
     |      >>> m = np.matrix('[1, 2; 3, 4]'); m
     |      matrix([[1, 2],
     |              [3, 4]])
     |      >>> m.getI()
     |      matrix([[-2. ,  1. ],
     |              [ 1.5, -0.5]])
     |      >>> m.getI() * m
     |      matrix([[ 1.,  0.], # may vary
     |              [ 0.,  1.]])
     |
     |  getT = T(self) from numpy.matrixlib.defmatrix.matrix
     |      Returns the transpose of the matrix.
     |
     |      Does *not* conjugate!  For the complex conjugate transpose, use ``.H``.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : matrix object
     |          The (non-conjugated) transpose of the matrix.
     |
     |      See Also
     |      --------
     |      transpose, getH
     |
     |      Examples
     |      --------
     |      >>> m = np.matrix('[1, 2; 3, 4]')
     |      >>> m
     |      matrix([[1, 2],
     |              [3, 4]])
     |      >>> m.getT()
     |      matrix([[1, 3],
     |              [2, 4]])
     |
     |  max(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Return the maximum value along an axis.
     |
     |      Parameters
     |      ----------
     |      See `amax` for complete descriptions
     |
     |      See Also
     |      --------
     |      amax, ndarray.max
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.max`, but returns a `matrix` object
     |      where `ndarray.max` would return an ndarray.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.max()
     |      11
     |      >>> x.max(0)
     |      matrix([[ 8,  9, 10, 11]])
     |      >>> x.max(1)
     |      matrix([[ 3],
     |              [ 7],
     |              [11]])
     |
     |  mean(self, axis=None, dtype=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Returns the average of the matrix elements along the given axis.
     |
     |      Refer to `numpy.mean` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.mean
     |
     |      Notes
     |      -----
     |      Same as `ndarray.mean` except that, where that returns an `ndarray`,
     |      this returns a `matrix` object.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3, 4)))
     |      >>> x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.mean()
     |      5.5
     |      >>> x.mean(0)
     |      matrix([[4., 5., 6., 7.]])
     |      >>> x.mean(1)
     |      matrix([[ 1.5],
     |              [ 5.5],
     |              [ 9.5]])
     |
     |  min(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Return the minimum value along an axis.
     |
     |      Parameters
     |      ----------
     |      See `amin` for complete descriptions.
     |
     |      See Also
     |      --------
     |      amin, ndarray.min
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.min`, but returns a `matrix` object
     |      where `ndarray.min` would return an ndarray.
     |
     |      Examples
     |      --------
     |      >>> x = -np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[  0,  -1,  -2,  -3],
     |              [ -4,  -5,  -6,  -7],
     |              [ -8,  -9, -10, -11]])
     |      >>> x.min()
     |      -11
     |      >>> x.min(0)
     |      matrix([[ -8,  -9, -10, -11]])
     |      >>> x.min(1)
     |      matrix([[ -3],
     |              [ -7],
     |              [-11]])
     |
     |  prod(self, axis=None, dtype=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Return the product of the array elements over the given axis.
     |
     |      Refer to `prod` for full documentation.
     |
     |      See Also
     |      --------
     |      prod, ndarray.prod
     |
     |      Notes
     |      -----
     |      Same as `ndarray.prod`, except, where that returns an `ndarray`, this
     |      returns a `matrix` object instead.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.prod()
     |      0
     |      >>> x.prod(0)
     |      matrix([[  0,  45, 120, 231]])
     |      >>> x.prod(1)
     |      matrix([[   0],
     |              [ 840],
     |              [7920]])
     |
     |  ptp(self, axis=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Peak-to-peak (maximum - minimum) value along the given axis.
     |
     |      Refer to `numpy.ptp` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.ptp
     |
     |      Notes
     |      -----
     |      Same as `ndarray.ptp`, except, where that would return an `ndarray` object,
     |      this returns a `matrix` object.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.ptp()
     |      11
     |      >>> x.ptp(0)
     |      matrix([[8, 8, 8, 8]])
     |      >>> x.ptp(1)
     |      matrix([[3],
     |              [3],
     |              [3]])
     |
     |  ravel(self, order='C') from numpy.matrixlib.defmatrix.matrix
     |      Return a flattened matrix.
     |
     |      Refer to `numpy.ravel` for more documentation.
     |
     |      Parameters
     |      ----------
     |      order : {'C', 'F', 'A', 'K'}, optional
     |          The elements of `m` are read using this index order. 'C' means to
     |          index the elements in C-like order, with the last axis index
     |          changing fastest, back to the first axis index changing slowest.
     |          'F' means to index the elements in Fortran-like index 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 `m` 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
     |      -------
     |      ret : matrix
     |          Return the matrix flattened to shape `(1, N)` where `N`
     |          is the number of elements in the original matrix.
     |          A copy is made only if necessary.
     |
     |      See Also
     |      --------
     |      matrix.flatten : returns a similar output matrix but always a copy
     |      matrix.flat : a flat iterator on the array.
     |      numpy.ravel : related function which returns an ndarray
     |
     |  squeeze(self, axis=None) from numpy.matrixlib.defmatrix.matrix
     |      Return a possibly reshaped matrix.
     |
     |      Refer to `numpy.squeeze` for more documentation.
     |
     |      Parameters
     |      ----------
     |      axis : None or int or tuple of ints, optional
     |          Selects a subset of the axes of length one in the shape.
     |          If an axis is selected with shape entry greater than one,
     |          an error is raised.
     |
     |      Returns
     |      -------
     |      squeezed : matrix
     |          The matrix, but as a (1, N) matrix if it had shape (N, 1).
     |
     |      See Also
     |      --------
     |      numpy.squeeze : related function
     |
     |      Notes
     |      -----
     |      If `m` has a single column then that column is returned
     |      as the single row of a matrix.  Otherwise `m` is returned.
     |      The returned matrix is always either `m` itself or a view into `m`.
     |      Supplying an axis keyword argument will not affect the returned matrix
     |      but it may cause an error to be raised.
     |
     |      Examples
     |      --------
     |      >>> c = np.matrix([[1], [2]])
     |      >>> c
     |      matrix([[1],
     |              [2]])
     |      >>> c.squeeze()
     |      matrix([[1, 2]])
     |      >>> r = c.T
     |      >>> r
     |      matrix([[1, 2]])
     |      >>> r.squeeze()
     |      matrix([[1, 2]])
     |      >>> m = np.matrix([[1, 2], [3, 4]])
     |      >>> m.squeeze()
     |      matrix([[1, 2],
     |              [3, 4]])
     |
     |  std(self, axis=None, dtype=None, out=None, ddof=0) from numpy.matrixlib.defmatrix.matrix
     |      Return the standard deviation of the array elements along the given axis.
     |
     |      Refer to `numpy.std` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.std
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.std`, except that where an `ndarray` would
     |      be returned, a `matrix` object is returned instead.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3, 4)))
     |      >>> x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.std()
     |      3.4520525295346629 # may vary
     |      >>> x.std(0)
     |      matrix([[ 3.26598632,  3.26598632,  3.26598632,  3.26598632]]) # may vary
     |      >>> x.std(1)
     |      matrix([[ 1.11803399],
     |              [ 1.11803399],
     |              [ 1.11803399]])
     |
     |  sum(self, axis=None, dtype=None, out=None) from numpy.matrixlib.defmatrix.matrix
     |      Returns the sum of the matrix elements, along the given axis.
     |
     |      Refer to `numpy.sum` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.sum
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.sum`, except that where an `ndarray` would
     |      be returned, a `matrix` object is returned instead.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix([[1, 2], [4, 3]])
     |      >>> x.sum()
     |      10
     |      >>> x.sum(axis=1)
     |      matrix([[3],
     |              [7]])
     |      >>> x.sum(axis=1, dtype='float')
     |      matrix([[3.],
     |              [7.]])
     |      >>> out = np.zeros((2, 1), dtype='float')
     |      >>> x.sum(axis=1, dtype='float', out=np.asmatrix(out))
     |      matrix([[3.],
     |              [7.]])
     |
     |  tolist(self) from numpy.matrixlib.defmatrix.matrix
     |      Return the matrix as a (possibly nested) list.
     |
     |      See `ndarray.tolist` for full documentation.
     |
     |      See Also
     |      --------
     |      ndarray.tolist
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.tolist()
     |      [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
     |
     |  var(self, axis=None, dtype=None, out=None, ddof=0) from numpy.matrixlib.defmatrix.matrix
     |      Returns the variance of the matrix elements, along the given axis.
     |
     |      Refer to `numpy.var` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.var
     |
     |      Notes
     |      -----
     |      This is the same as `ndarray.var`, except that where an `ndarray` would
     |      be returned, a `matrix` object is returned instead.
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3, 4)))
     |      >>> x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.var()
     |      11.916666666666666
     |      >>> x.var(0)
     |      matrix([[ 10.66666667,  10.66666667,  10.66666667,  10.66666667]]) # may vary
     |      >>> x.var(1)
     |      matrix([[1.25],
     |              [1.25],
     |              [1.25]])
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(subtype, data, dtype=None, copy=True) from numpy.matrixlib.defmatrix.matrix
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  A
     |      Return `self` as an `ndarray` object.
     |
     |      Equivalent to ``np.asarray(self)``.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : ndarray
     |          `self` as an `ndarray`
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.getA()
     |      array([[ 0,  1,  2,  3],
     |             [ 4,  5,  6,  7],
     |             [ 8,  9, 10, 11]])
     |
     |  A1
     |      Return `self` as a flattened `ndarray`.
     |
     |      Equivalent to ``np.asarray(x).ravel()``
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : ndarray
     |          `self`, 1-D, as an `ndarray`
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4))); x
     |      matrix([[ 0,  1,  2,  3],
     |              [ 4,  5,  6,  7],
     |              [ 8,  9, 10, 11]])
     |      >>> x.getA1()
     |      array([ 0,  1,  2, ...,  9, 10, 11])
     |
     |  H
     |      Returns the (complex) conjugate transpose of `self`.
     |
     |      Equivalent to ``np.transpose(self)`` if `self` is real-valued.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : matrix object
     |          complex conjugate transpose of `self`
     |
     |      Examples
     |      --------
     |      >>> x = np.matrix(np.arange(12).reshape((3,4)))
     |      >>> z = x - 1j*x; z
     |      matrix([[  0. +0.j,   1. -1.j,   2. -2.j,   3. -3.j],
     |              [  4. -4.j,   5. -5.j,   6. -6.j,   7. -7.j],
     |              [  8. -8.j,   9. -9.j,  10.-10.j,  11.-11.j]])
     |      >>> z.getH()
     |      matrix([[ 0. -0.j,  4. +4.j,  8. +8.j],
     |              [ 1. +1.j,  5. +5.j,  9. +9.j],
     |              [ 2. +2.j,  6. +6.j, 10.+10.j],
     |              [ 3. +3.j,  7. +7.j, 11.+11.j]])
     |
     |  I
     |      Returns the (multiplicative) inverse of invertible `self`.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : matrix object
     |          If `self` is non-singular, `ret` is such that ``ret * self`` ==
     |          ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return
     |          ``True``.
     |
     |      Raises
     |      ------
     |      numpy.linalg.LinAlgError: Singular matrix
     |          If `self` is singular.
     |
     |      See Also
     |      --------
     |      linalg.inv
     |
     |      Examples
     |      --------
     |      >>> m = np.matrix('[1, 2; 3, 4]'); m
     |      matrix([[1, 2],
     |              [3, 4]])
     |      >>> m.getI()
     |      matrix([[-2. ,  1. ],
     |              [ 1.5, -0.5]])
     |      >>> m.getI() * m
     |      matrix([[ 1.,  0.], # may vary
     |              [ 0.,  1.]])
     |
     |  T
     |      Returns the transpose of the matrix.
     |
     |      Does *not* conjugate!  For the complex conjugate transpose, use ``.H``.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      ret : matrix object
     |          The (non-conjugated) transpose of the matrix.
     |
     |      See Also
     |      --------
     |      transpose, getH
     |
     |      Examples
     |      --------
     |      >>> m = np.matrix('[1, 2; 3, 4]')
     |      >>> m
     |      matrix([[1, 2],
     |              [3, 4]])
     |      >>> m.getT()
     |      matrix([[1, 3],
     |              [2, 4]])
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}
     |
     |  __array_priority__ = 10.0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ndarray:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      a.__array__([dtype], *, copy=None)
     |
     |      For ``dtype`` parameter it returns a new reference to self if
     |      ``dtype`` is not given or it matches array's data type.
     |      A new array of provided data type is returned if ``dtype``
     |      is different from the current data type of the array.
     |      For ``copy`` parameter it returns a new reference to self if
     |      ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype``
     |      parameter. The method returns a new array for ``copy=True``, regardless of
     |      ``dtype`` parameter.
     |
     |      A more detailed explanation of the ``__array__`` interface
     |      can be found in :ref:`dunder_array.interface`.
     |
     |  __array_function__(...)
     |
     |  __array_namespace__(...)
     |
     |  __array_ufunc__(...)
     |
     |  __array_wrap__(...)
     |      a.__array_wrap__(array[, context], /)
     |
     |      Returns a view of `array` with the same type as self.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __contains__(self, key, /)
     |      Return bool(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, /)
     |
     |      Used if :func:`copy.deepcopy` is called on an array.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __dlpack__(...)
     |      a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __dlpack_device__(...)
     |      a.__dlpack_device__()
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      Default object formatter.
     |
     |      Return str(self) if format_spec is empty. Raise TypeError otherwise.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __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.
     |
     |  __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.
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __reduce__(...)
     |      a.__reduce__()
     |
     |      For pickling.
     |
     |  __reduce_ex__(...)
     |      Helper for pickle.
     |
     |  __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.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __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__(...)
     |      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.
     |
     |  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=None, 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
     |      -----
     |      .. versionchanged:: 1.17.0
     |         Casting between a simple data type and a structured one is possible only
     |         for "unsafe" casting.  Casting to multiple fields is allowed, but
     |         casting from multiple fields is not.
     |
     |      .. versionchanged:: 1.9.0
     |         Casting from numeric to string types in 'safe' casting mode requires
     |         that the string dtype length is long enough to store the max
     |         integer/float value converted.
     |
     |      Raises
     |      ------
     |      ComplexWarning
     |          When casting from complex to float or int. To avoid this,
     |          one should use ``a.real.astype(t)``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |      Arrays of byte-strings are not swapped. The real and imaginary
     |      parts of a complex number are swapped individually.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
     |      >>> list(map(hex, A))
     |      ['0x1', '0x100', '0x2233']
     |      >>> A.byteswap(inplace=True)
     |      array([  256,     1, 13090], dtype=int16)
     |      >>> list(map(hex, A))
     |      ['0x100', '0x1', '0x3322']
     |
     |      Arrays of byte-strings are not swapped
     |
     |      >>> A = np.array([b'ceg', b'fac'])
     |      >>> A.byteswap()
     |      array([b'ceg', b'fac'], dtype='|S3')
     |
     |      ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with
     |      the same values but different representation in memory
     |
     |      >>> A = np.array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
     |             0, 0], dtype=uint8)
     |      >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
     |      array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
     |             0, 3], dtype=uint8)
     |
     |  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, **kwargs)
     |
     |      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, and this function always passes sub-classes through.)
     |
     |      See also
     |      --------
     |      numpy.copy : Similar function with different default behavior
     |      numpy.copyto
     |
     |      Notes
     |      -----
     |      This function is the preferred method for creating an array copy.  The
     |      function :func:`numpy.copy` is similar, but it defaults to using order 'K',
     |      and will not pass sub-classes through by default.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |
     |      For arrays containing Python objects (e.g. dtype=object),
     |      the copy is a shallow one. The new array will contain the
     |      same object which may lead to surprises if that object can
     |      be modified (is mutable):
     |
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> b = a.copy()
     |      >>> b[2][0] = 10
     |      >>> a
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |
     |      To ensure all elements within an ``object`` array are copied,
     |      use `copy.deepcopy`:
     |
     |      >>> import copy
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> c = copy.deepcopy(a)
     |      >>> c[2][0] = 10
     |      >>> c
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |      >>> a
     |      array([1, 'm', list([2, 3, 4])], dtype=object)
     |
     |  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(...)
     |
     |  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 or Path
     |          A string naming the dump file.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |  dumps(...)
     |      a.dumps()
     |
     |      Returns the pickle of the array as a string.
     |      pickle.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
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([1, 2])
     |      >>> a.fill(0)
     |      >>> a
     |      array([0, 0])
     |      >>> a = np.empty(2)
     |      >>> a.fill(1)
     |      >>> a
     |      array([1.,  1.])
     |
     |      Fill expects a scalar value and always behaves the same as assigning
     |      to a single array element.  The following is a rare example where this
     |      distinction is important:
     |
     |      >>> a = np.array([None, None], dtype=object)
     |      >>> a[0] = np.array(3)
     |      >>> a
     |      array([array(3), None], dtype=object)
     |      >>> a.fill(np.array(3))
     |      >>> a
     |      array([array(3), array(3)], dtype=object)
     |
     |      Where other forms of assignments will unpack the array being assigned:
     |
     |      >>> a[...] = np.array(3)
     |      >>> a
     |      array([3, 3], dtype=object)
     |
     |  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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> np.random.seed(123)
     |      >>> x = np.random.randint(9, size=(3, 3))
     |      >>> x
     |      array([[2, 2, 6],
     |             [1, 3, 6],
     |             [1, 0, 1]])
     |      >>> x.item(3)
     |      1
     |      >>> x.item(7)
     |      0
     |      >>> x.item((0, 1))
     |      2
     |      >>> x.item((2, 2))
     |      1
     |
     |      For an array with object dtype, elements are returned as-is.
     |
     |      >>> a = np.array([np.int64(1)], dtype=object)
     |      >>> a.item() #return np.int64
     |      np.int64(1)
     |
     |  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)
     |
     |      Partially sorts the elements in the array in such a way that the value of
     |      the element in k-th position is in the position it would be in a sorted
     |      array. In the output array, all elements smaller than the k-th element
     |      are located to the left of this element and all equal or greater are
     |      located to its right. The ordering of the elements in the two partitions
     |      on the either side of the k-th element in the output array 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 of 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.
     |
     |          .. deprecated:: 1.22.0
     |              Passing booleans as index is deprecated.
     |      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 to 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 partitioned copy of an array.
     |      argpartition : Indirect partition.
     |      sort : Full sort.
     |
     |      Notes
     |      -----
     |      See ``np.partition`` for notes on the different algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([3, 4, 2, 1])
     |      >>> a.partition(3)
     |      >>> a
     |      array([2, 1, 3, 4]) # may vary
     |
     |      >>> a.partition((1, 3))
     |      >>> a
     |      array([1, 2, 3, 4])
     |
     |  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
     |
     |  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', copy=None)
     |
     |      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:
     |
     |      >>> import numpy as np
     |
     |      >>> 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 references or is 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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]], dtype=int32)
     |      >>> x
     |      array([[1.0e+000, 1.5e-323, 1.5e-323],
     |             [1.5e-323, 1.0e+000, 1.5e-323],
     |             [1.5e-323, 1.5e-323, 1.0e+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,
     |      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 flag 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 three of which can be changed by the user:
     |      WRITEBACKIFCOPY, 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);
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> y = np.array([[3, 1, 7],
     |      ...               [2, 0, 0],
     |      ...               [8, 5, 9]])
     |      >>> 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
     |      >>> y.setflags(write=0, align=0)
     |      >>> y.flags
     |        C_CONTIGUOUS : True
     |        F_CONTIGUOUS : False
     |        OWNDATA : True
     |        WRITEABLE : False
     |        ALIGNED : False
     |        WRITEBACKIFCOPY : 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=None, order=None)
     |
     |      Sort an array in-place. Refer to `numpy.sort` for full documentation.
     |
     |      Parameters
     |      ----------
     |      axis : int, optional
     |          Axis along which to sort. Default is -1, which means sort along the
     |          last axis.
     |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
     |          Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
     |          and 'mergesort' use timsort under the covers and, in general, the
     |          actual implementation will vary with datatype. The 'mergesort' option
     |          is retained for backwards compatibility.
     |
     |          .. versionchanged:: 1.15.0
     |             The 'stable' option was added.
     |
     |      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.
     |      numpy.argsort : Indirect sort.
     |      numpy.lexsort : Indirect stable sort on multiple keys.
     |      numpy.searchsorted : Find elements in sorted array.
     |      numpy.partition: Partial sort.
     |
     |      Notes
     |      -----
     |      See `numpy.sort` for notes on the different sorting algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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([(b'c', 1), (b'a', 2)],
     |            dtype=[('x', 'S1'), ('y', '<i8')])
     |
     |  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
     |
     |  to_device(...)
     |
     |  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 is produced in C-order by default.
     |      This behavior is controlled by the ``order`` parameter.
     |
     |      .. versionadded:: 1.9.0
     |
     |      Parameters
     |      ----------
     |      order : {'C', 'F', 'A'}, optional
     |          Controls the memory layout of the bytes object. 'C' means C-order,
     |          'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
     |          Fortran contiguous, 'C' otherwise. Default is 'C'.
     |
     |      Returns
     |      -------
     |      s : bytes
     |          Python bytes exhibiting a copy of `a`'s raw data.
     |
     |      See also
     |      --------
     |      frombuffer
     |          Inverse of this operation, construct a 1-dimensional array from Python
     |          bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
     |      >>> x.tobytes()
     |      b'\x00\x00\x01\x00\x02\x00\x03\x00'
     |      >>> x.tobytes('C') == x.tobytes()
     |      True
     |      >>> x.tobytes('F')
     |      b'\x00\x00\x02\x00\x01\x00\x03\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 or Path
     |          An open file object, or a string containing a filename.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |      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.
     |
     |      When fid is a file object, array contents are directly written to the
     |      file, bypassing the file object's ``write`` method. As a result, tofile
     |      cannot be used with files objects supporting compression (e.g., GzipFile)
     |      or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
     |
     |  tostring(...)
     |      a.tostring(order='C')
     |
     |      A compatibility alias for `~ndarray.tobytes`, with exactly the same
     |      behavior.
     |
     |      Despite its name, it returns :class:`bytes` not :class:`str`\ s.
     |
     |      .. deprecated:: 1.19.0
     |
     |  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.
     |
     |      Refer to `numpy.transpose` for full documentation.
     |
     |      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 that the
     |         array's `i`-th axis becomes the transposed array'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
     |      -------
     |      p : ndarray
     |          View of the array with its axes suitably permuted.
     |
     |      See Also
     |      --------
     |      transpose : Equivalent function.
     |      ndarray.T : Array property returning the array transposed.
     |      ndarray.reshape : Give a new shape to an array without changing its data.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.transpose()
     |      array([1, 2, 3, 4])
     |
     |  view(...)
     |      a.view([dtype][, type])
     |
     |      New view of array with the same data.
     |
     |      .. note::
     |          Passing None for ``dtype`` is different from omitting the parameter,
     |          since the former invokes ``dtype(None)`` which is an alias for
     |          ``dtype('float64')``.
     |
     |      Parameters
     |      ----------
     |      dtype : data-type or ndarray sub-class, optional
     |          Data-type descriptor of the returned view, e.g., float32 or int16.
     |          Omitting it 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, omission
     |          of the parameter 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 last axis of ``a`` must be
     |      contiguous. This axis will be resized in the result.
     |
     |      .. versionchanged:: 1.23.0
     |         Only the last axis needs to be contiguous. Previously, the entire array
     |         had to be C-contiguous.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
     |
     |      Viewing array data using a different type and dtype:
     |
     |      >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
     |      >>> y = x.view(dtype=nonneg, type=np.recarray)
     |      >>> x["a"]
     |      array([-1], dtype=int8)
     |      >>> y.a
     |      array([255], dtype=uint8)
     |
     |      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
     |      >>> x
     |      array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      Using a view to convert an array to a recarray:
     |
     |      >>> z = x.view(np.recarray)
     |      >>> z.a
     |      array([1, 3], dtype=int8)
     |
     |      Views share data:
     |
     |      >>> x[0] = (9, 10)
     |      >>> z[0]
     |      np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      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[:, ::2]
     |      >>> y
     |      array([[1, 3],
     |             [4, 6]], dtype=int16)
     |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      Traceback (most recent call last):
     |          ...
     |      ValueError: To change to a dtype of a different size, the last axis must be contiguous
     |      >>> z = y.copy()
     |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      array([[(1, 3)],
     |             [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
     |
     |      However, views that change dtype are totally fine for arrays with a
     |      contiguous last axis, even if the rest of the axes are not C-contiguous:
     |
     |      >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
     |      >>> x.transpose(1, 0, 2).view(np.int16)
     |      array([[[ 256,  770],
     |              [3340, 3854]],
     |      <BLANKLINE>
     |             [[1284, 1798],
     |              [4368, 4882]],
     |      <BLANKLINE>
     |             [[2312, 2826],
     |              [5396, 5910]]], dtype=int16)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from ndarray:
     |
     |  __class_getitem__(...)
     |      a.__class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.ndarray` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.ndarray` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.ndarray[Any, np.dtype[Any]]
     |      numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |      numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
     |                          w.r.t. its `dtype.type <numpy.dtype.type>`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ndarray:
     |
     |  __array_interface__
     |      Array protocol: Python side.
     |
     |  __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:
     |
     |      >>> import numpy as np
     |      >>> 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):
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.data
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.shape
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.strides
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.data_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.shape_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.strides_as
     |          :noindex:
     |
     |      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 numpy as np
     |      >>> import ctypes
     |      >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
     |      >>> x
     |      array([[0, 1],
     |             [2, 3]], dtype=int32)
     |      >>> x.ctypes.data
     |      31962608 # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
     |      <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
     |      c_uint(0)
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
     |      c_ulong(4294967296)
     |      >>> x.ctypes.shape
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
     |      >>> x.ctypes.strides
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
     |
     |  data
     |      Python buffer object pointing to the start of the array's data.
     |
     |  device
     |
     |  dtype
     |      Data-type of the array's elements.
     |
     |      .. warning::
     |
     |          Setting ``arr.dtype`` is discouraged and may be deprecated in the
     |          future.  Setting will replace the ``dtype`` without modifying the
     |          memory (see also `ndarray.view` and `ndarray.astype`).
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      d : numpy dtype object
     |
     |      See Also
     |      --------
     |      ndarray.astype : Cast the values contained in the array to a new data-type.
     |      ndarray.view : Create a view of the same data but a different data-type.
     |      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.
     |      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, 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:
     |
     |      - 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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)
     |      <class '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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.sqrt([1+0j, 0+1j])
     |      >>> x.imag
     |      array([ 0.        ,  0.70710678])
     |      >>> x.imag.dtype
     |      dtype('float64')
     |
     |  itemset
     |
     |  itemsize
     |      Length of one array element in bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1,2,3], dtype=np.float64)
     |      >>> x.itemsize
     |      8
     |      >>> x = np.array([1,2,3], dtype=np.complex128)
     |      >>> x.itemsize
     |      16
     |
     |  mT
     |      View of the matrix transposed array.
     |
     |      The matrix transpose is the transpose of the last two dimensions, even
     |      if the array is of higher dimension.
     |
     |      .. versionadded:: 2.0
     |
     |      Raises
     |      ------
     |      ValueError
     |          If the array is of dimension less than 2.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.mT
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.arange(8).reshape((2, 2, 2))
     |      >>> a
     |      array([[[0, 1],
     |              [2, 3]],
     |      <BLANKLINE>
     |             [[4, 5],
     |              [6, 7]]])
     |      >>> a.mT
     |      array([[[0, 2],
     |              [1, 3]],
     |      <BLANKLINE>
     |             [[4, 6],
     |              [5, 7]]])
     |
     |  nbytes
     |      Total bytes consumed by the elements of the array.
     |
     |      Notes
     |      -----
     |      Does not include memory consumed by non-element attributes of the
     |      array object.
     |
     |      See Also
     |      --------
     |      sys.getsizeof
     |          Memory consumed by the object itself without parents in case view.
     |          This does include memory consumed by non-element attributes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> x.ndim
     |      1
     |      >>> y = np.zeros((2, 3, 4))
     |      >>> y.ndim
     |      3
     |
     |  newbyteorder
     |
     |  real
     |      The real part of the array.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |
     |      .. warning::
     |
     |          Setting ``arr.shape`` is discouraged and may be deprecated in the
     |          future.  Using `ndarray.reshape` is the preferred approach.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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 in-place modification. Use
     |      `.reshape()` to make a copy with the desired shape.
     |
     |      See Also
     |      --------
     |      numpy.shape : Equivalent getter function.
     |      numpy.reshape : Function similar to setting ``shape``.
     |      ndarray.reshape : Method similar to setting ``shape``.
     |
     |  size
     |      Number of elements in the array.
     |
     |      Equal to ``np.prod(a.shape)``, i.e., the product of the array's
     |      dimensions.
     |
     |      Notes
     |      -----
     |      `a.size` returns a standard arbitrary precision Python integer. This
     |      may not be the case with other methods of obtaining the same value
     |      (like the suggested ``np.prod(a.shape)``, which returns an instance
     |      of ``np.int_``), and may be relevant if the value is used further in
     |      calculations that may overflow a fixed size integer type.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      :ref:`arrays.ndarray`.
     |
     |      .. warning::
     |
     |          Setting ``arr.strides`` is discouraged and may be deprecated in the
     |          future.  `numpy.lib.stride_tricks.as_strided` should be preferred
     |          to create a new view of the same data in a safer way.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> 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 ndarray:
     |
     |  __hash__ = None

    class memmap(ndarray)
     |  memmap(filename, dtype=<class 'numpy.uint8'>, mode='r+', offset=0, shape=None, order='C')
     |
     |  Create a memory-map to an array stored in a *binary* file on disk.
     |
     |  Memory-mapped files are used for accessing small segments of large files
     |  on disk, without reading the entire file into memory.  NumPy's
     |  memmap's are array-like objects.  This differs from Python's ``mmap``
     |  module, which uses file-like objects.
     |
     |  This subclass of ndarray has some unpleasant interactions with
     |  some operations, because it doesn't quite fit properly as a subclass.
     |  An alternative to using this subclass is to create the ``mmap``
     |  object yourself, then create an ndarray with ndarray.__new__ directly,
     |  passing the object created in its 'buffer=' parameter.
     |
     |  This class may at some point be turned into a factory function
     |  which returns a view into an mmap buffer.
     |
     |  Flush the memmap instance to write the changes to the file. Currently there
     |  is no API to close the underlying ``mmap``. It is tricky to ensure the
     |  resource is actually closed, since it may be shared between different
     |  memmap instances.
     |
     |
     |  Parameters
     |  ----------
     |  filename : str, file-like object, or pathlib.Path instance
     |      The file name or file object to be used as the array data buffer.
     |  dtype : data-type, optional
     |      The data-type used to interpret the file contents.
     |      Default is `uint8`.
     |  mode : {'r+', 'r', 'w+', 'c'}, optional
     |      The file is opened in this mode:
     |
     |      +------+-------------------------------------------------------------+
     |      | 'r'  | Open existing file for reading only.                        |
     |      +------+-------------------------------------------------------------+
     |      | 'r+' | Open existing file for reading and writing.                 |
     |      +------+-------------------------------------------------------------+
     |      | 'w+' | Create or overwrite existing file for reading and writing.  |
     |      |      | If ``mode == 'w+'`` then `shape` must also be specified.    |
     |      +------+-------------------------------------------------------------+
     |      | 'c'  | Copy-on-write: assignments affect data in memory, but       |
     |      |      | changes are not saved to disk.  The file on disk is         |
     |      |      | read-only.                                                  |
     |      +------+-------------------------------------------------------------+
     |
     |      Default is 'r+'.
     |  offset : int, optional
     |      In the file, array data starts at this offset. Since `offset` is
     |      measured in bytes, it should normally be a multiple of the byte-size
     |      of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of
     |      file are valid; The file will be extended to accommodate the
     |      additional data. By default, ``memmap`` will start at the beginning of
     |      the file, even if ``filename`` is a file pointer ``fp`` and
     |      ``fp.tell() != 0``.
     |  shape : int or sequence of ints, optional
     |      The desired shape of the array. If ``mode == 'r'`` and the number
     |      of remaining bytes after `offset` is not a multiple of the byte-size
     |      of `dtype`, you must specify `shape`. By default, the returned array
     |      will be 1-D with the number of elements determined by file size
     |      and data-type.
     |
     |      .. versionchanged:: 2.0
     |       The shape parameter can now be any integer sequence type, previously
     |       types were limited to tuple and int.
     |
     |  order : {'C', 'F'}, optional
     |      Specify the order of the ndarray memory layout:
     |      :term:`row-major`, C-style or :term:`column-major`,
     |      Fortran-style.  This only has an effect if the shape is
     |      greater than 1-D.  The default order is 'C'.
     |
     |  Attributes
     |  ----------
     |  filename : str or pathlib.Path instance
     |      Path to the mapped file.
     |  offset : int
     |      Offset position in the file.
     |  mode : str
     |      File mode.
     |
     |  Methods
     |  -------
     |  flush
     |      Flush any changes in memory to file on disk.
     |      When you delete a memmap object, flush is called first to write
     |      changes to disk.
     |
     |
     |  See also
     |  --------
     |  lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
     |
     |  Notes
     |  -----
     |  The memmap object can be used anywhere an ndarray is accepted.
     |  Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns
     |  ``True``.
     |
     |  Memory-mapped files cannot be larger than 2GB on 32-bit systems.
     |
     |  When a memmap causes a file to be created or extended beyond its
     |  current size in the filesystem, the contents of the new part are
     |  unspecified. On systems with POSIX filesystem semantics, the extended
     |  part will be filled with zero bytes.
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> data = np.arange(12, dtype='float32')
     |  >>> data.resize((3,4))
     |
     |  This example uses a temporary file so that doctest doesn't write
     |  files to your directory. You would use a 'normal' filename.
     |
     |  >>> from tempfile import mkdtemp
     |  >>> import os.path as path
     |  >>> filename = path.join(mkdtemp(), 'newfile.dat')
     |
     |  Create a memmap with dtype and shape that matches our data:
     |
     |  >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
     |  >>> fp
     |  memmap([[0., 0., 0., 0.],
     |          [0., 0., 0., 0.],
     |          [0., 0., 0., 0.]], dtype=float32)
     |
     |  Write data to memmap array:
     |
     |  >>> fp[:] = data[:]
     |  >>> fp
     |  memmap([[  0.,   1.,   2.,   3.],
     |          [  4.,   5.,   6.,   7.],
     |          [  8.,   9.,  10.,  11.]], dtype=float32)
     |
     |  >>> fp.filename == path.abspath(filename)
     |  True
     |
     |  Flushes memory changes to disk in order to read them back
     |
     |  >>> fp.flush()
     |
     |  Load the memmap and verify data was stored:
     |
     |  >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
     |  >>> newfp
     |  memmap([[  0.,   1.,   2.,   3.],
     |          [  4.,   5.,   6.,   7.],
     |          [  8.,   9.,  10.,  11.]], dtype=float32)
     |
     |  Read-only memmap:
     |
     |  >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
     |  >>> fpr.flags.writeable
     |  False
     |
     |  Copy-on-write memmap:
     |
     |  >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
     |  >>> fpc.flags.writeable
     |  True
     |
     |  It's possible to assign to copy-on-write array, but values are only
     |  written into the memory copy of the array, and not written to disk:
     |
     |  >>> fpc
     |  memmap([[  0.,   1.,   2.,   3.],
     |          [  4.,   5.,   6.,   7.],
     |          [  8.,   9.,  10.,  11.]], dtype=float32)
     |  >>> fpc[0,:] = 0
     |  >>> fpc
     |  memmap([[  0.,   0.,   0.,   0.],
     |          [  4.,   5.,   6.,   7.],
     |          [  8.,   9.,  10.,  11.]], dtype=float32)
     |
     |  File on disk is unchanged:
     |
     |  >>> fpr
     |  memmap([[  0.,   1.,   2.,   3.],
     |          [  4.,   5.,   6.,   7.],
     |          [  8.,   9.,  10.,  11.]], dtype=float32)
     |
     |  Offset into a memmap:
     |
     |  >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
     |  >>> fpo
     |  memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32)
     |
     |  Method resolution order:
     |      memmap
     |      ndarray
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __array_finalize__(self, obj) from numpy._core.memmap.memmap
     |      a.__array_finalize__(obj, /)
     |
     |      Present so subclasses can call super. Does nothing.
     |
     |  __array_wrap__(self, arr, context=None, return_scalar=False) from numpy._core.memmap.memmap
     |      a.__array_wrap__(array[, context], /)
     |
     |      Returns a view of `array` with the same type as self.
     |
     |  __getitem__(self, index) from numpy._core.memmap.memmap
     |      Return self[key].
     |
     |  flush(self) from numpy._core.memmap.memmap
     |      Write any changes in the array to the file on disk.
     |
     |      For further information, see `memmap`.
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      See Also
     |      --------
     |      memmap
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(subtype, filename, dtype=<class 'numpy.uint8'>, mode='r+', offset=0, shape=None, order='C') from numpy._core.memmap.memmap
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __array_priority__ = -100.0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ndarray:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      a.__array__([dtype], *, copy=None)
     |
     |      For ``dtype`` parameter it returns a new reference to self if
     |      ``dtype`` is not given or it matches array's data type.
     |      A new array of provided data type is returned if ``dtype``
     |      is different from the current data type of the array.
     |      For ``copy`` parameter it returns a new reference to self if
     |      ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype``
     |      parameter. The method returns a new array for ``copy=True``, regardless of
     |      ``dtype`` parameter.
     |
     |      A more detailed explanation of the ``__array__`` interface
     |      can be found in :ref:`dunder_array.interface`.
     |
     |  __array_function__(...)
     |
     |  __array_namespace__(...)
     |
     |  __array_ufunc__(...)
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __contains__(self, key, /)
     |      Return bool(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, /)
     |
     |      Used if :func:`copy.deepcopy` is called on an array.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __dlpack__(...)
     |      a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __dlpack_device__(...)
     |      a.__dlpack_device__()
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      Default object formatter.
     |
     |      Return str(self) if format_spec is empty. Raise TypeError otherwise.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __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.
     |
     |  __reduce_ex__(...)
     |      Helper for pickle.
     |
     |  __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__(...)
     |      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, *, where=True)
     |
     |      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, *, where=True)
     |
     |      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, *, keepdims=False)
     |
     |      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, *, keepdims=False)
     |
     |      Return indices of the minimum values along the given axis.
     |
     |      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=None, 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
     |      -----
     |      .. versionchanged:: 1.17.0
     |         Casting between a simple data type and a structured one is possible only
     |         for "unsafe" casting.  Casting to multiple fields is allowed, but
     |         casting from multiple fields is not.
     |
     |      .. versionchanged:: 1.9.0
     |         Casting from numeric to string types in 'safe' casting mode requires
     |         that the string dtype length is long enough to store the max
     |         integer/float value converted.
     |
     |      Raises
     |      ------
     |      ComplexWarning
     |          When casting from complex to float or int. To avoid this,
     |          one should use ``a.real.astype(t)``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |      Arrays of byte-strings are not swapped. The real and imaginary
     |      parts of a complex number are swapped individually.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
     |      >>> list(map(hex, A))
     |      ['0x1', '0x100', '0x2233']
     |      >>> A.byteswap(inplace=True)
     |      array([  256,     1, 13090], dtype=int16)
     |      >>> list(map(hex, A))
     |      ['0x100', '0x1', '0x3322']
     |
     |      Arrays of byte-strings are not swapped
     |
     |      >>> A = np.array([b'ceg', b'fac'])
     |      >>> A.byteswap()
     |      array([b'ceg', b'fac'], dtype='|S3')
     |
     |      ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with
     |      the same values but different representation in memory
     |
     |      >>> A = np.array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
     |             0, 0], dtype=uint8)
     |      >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
     |      array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
     |             0, 3], dtype=uint8)
     |
     |  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, **kwargs)
     |
     |      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, and this function always passes sub-classes through.)
     |
     |      See also
     |      --------
     |      numpy.copy : Similar function with different default behavior
     |      numpy.copyto
     |
     |      Notes
     |      -----
     |      This function is the preferred method for creating an array copy.  The
     |      function :func:`numpy.copy` is similar, but it defaults to using order 'K',
     |      and will not pass sub-classes through by default.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |
     |      For arrays containing Python objects (e.g. dtype=object),
     |      the copy is a shallow one. The new array will contain the
     |      same object which may lead to surprises if that object can
     |      be modified (is mutable):
     |
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> b = a.copy()
     |      >>> b[2][0] = 10
     |      >>> a
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |
     |      To ensure all elements within an ``object`` array are copied,
     |      use `copy.deepcopy`:
     |
     |      >>> import copy
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> c = copy.deepcopy(a)
     |      >>> c[2][0] = 10
     |      >>> c
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |      >>> a
     |      array([1, 'm', list([2, 3, 4])], dtype=object)
     |
     |  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(...)
     |
     |  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 or Path
     |          A string naming the dump file.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |  dumps(...)
     |      a.dumps()
     |
     |      Returns the pickle of the array as a string.
     |      pickle.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
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([1, 2])
     |      >>> a.fill(0)
     |      >>> a
     |      array([0, 0])
     |      >>> a = np.empty(2)
     |      >>> a.fill(1)
     |      >>> a
     |      array([1.,  1.])
     |
     |      Fill expects a scalar value and always behaves the same as assigning
     |      to a single array element.  The following is a rare example where this
     |      distinction is important:
     |
     |      >>> a = np.array([None, None], dtype=object)
     |      >>> a[0] = np.array(3)
     |      >>> a
     |      array([array(3), None], dtype=object)
     |      >>> a.fill(np.array(3))
     |      >>> a
     |      array([array(3), array(3)], dtype=object)
     |
     |      Where other forms of assignments will unpack the array being assigned:
     |
     |      >>> a[...] = np.array(3)
     |      >>> a
     |      array([3, 3], dtype=object)
     |
     |  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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> np.random.seed(123)
     |      >>> x = np.random.randint(9, size=(3, 3))
     |      >>> x
     |      array([[2, 2, 6],
     |             [1, 3, 6],
     |             [1, 0, 1]])
     |      >>> x.item(3)
     |      1
     |      >>> x.item(7)
     |      0
     |      >>> x.item((0, 1))
     |      2
     |      >>> x.item((2, 2))
     |      1
     |
     |      For an array with object dtype, elements are returned as-is.
     |
     |      >>> a = np.array([np.int64(1)], dtype=object)
     |      >>> a.item() #return np.int64
     |      np.int64(1)
     |
     |  max(...)
     |      a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
     |
     |      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, *, where=True)
     |
     |      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, initial=<no value>, where=True)
     |
     |      Return the minimum along a given axis.
     |
     |      Refer to `numpy.amin` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.amin : equivalent function
     |
     |  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)
     |
     |      Partially sorts the elements in the array in such a way that the value of
     |      the element in k-th position is in the position it would be in a sorted
     |      array. In the output array, all elements smaller than the k-th element
     |      are located to the left of this element and all equal or greater are
     |      located to its right. The ordering of the elements in the two partitions
     |      on the either side of the k-th element in the output array 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 of 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.
     |
     |          .. deprecated:: 1.22.0
     |              Passing booleans as index is deprecated.
     |      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 to 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 partitioned copy of an array.
     |      argpartition : Indirect partition.
     |      sort : Full sort.
     |
     |      Notes
     |      -----
     |      See ``np.partition`` for notes on the different algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([3, 4, 2, 1])
     |      >>> a.partition(3)
     |      >>> a
     |      array([2, 1, 3, 4]) # may vary
     |
     |      >>> a.partition((1, 3))
     |      >>> a
     |      array([1, 2, 3, 4])
     |
     |  prod(...)
     |      a.prod(axis=None, dtype=None, out=None, keepdims=False,
     |          initial=1, where=True)
     |
     |      Return the product of the array elements over the given axis
     |
     |      Refer to `numpy.prod` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.prod : 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', copy=None)
     |
     |      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:
     |
     |      >>> import numpy as np
     |
     |      >>> 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 references or is 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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]], dtype=int32)
     |      >>> x
     |      array([[1.0e+000, 1.5e-323, 1.5e-323],
     |             [1.5e-323, 1.0e+000, 1.5e-323],
     |             [1.5e-323, 1.5e-323, 1.0e+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,
     |      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 flag 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 three of which can be changed by the user:
     |      WRITEBACKIFCOPY, 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);
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> y = np.array([[3, 1, 7],
     |      ...               [2, 0, 0],
     |      ...               [8, 5, 9]])
     |      >>> 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
     |      >>> y.setflags(write=0, align=0)
     |      >>> y.flags
     |        C_CONTIGUOUS : True
     |        F_CONTIGUOUS : False
     |        OWNDATA : True
     |        WRITEABLE : False
     |        ALIGNED : False
     |        WRITEBACKIFCOPY : 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=None, order=None)
     |
     |      Sort an array in-place. Refer to `numpy.sort` for full documentation.
     |
     |      Parameters
     |      ----------
     |      axis : int, optional
     |          Axis along which to sort. Default is -1, which means sort along the
     |          last axis.
     |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
     |          Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
     |          and 'mergesort' use timsort under the covers and, in general, the
     |          actual implementation will vary with datatype. The 'mergesort' option
     |          is retained for backwards compatibility.
     |
     |          .. versionchanged:: 1.15.0
     |             The 'stable' option was added.
     |
     |      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.
     |      numpy.argsort : Indirect sort.
     |      numpy.lexsort : Indirect stable sort on multiple keys.
     |      numpy.searchsorted : Find elements in sorted array.
     |      numpy.partition: Partial sort.
     |
     |      Notes
     |      -----
     |      See `numpy.sort` for notes on the different sorting algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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([(b'c', 1), (b'a', 2)],
     |            dtype=[('x', 'S1'), ('y', '<i8')])
     |
     |  squeeze(...)
     |      a.squeeze(axis=None)
     |
     |      Remove axes of length one from `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, *, where=True)
     |
     |      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, initial=0, where=True)
     |
     |      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
     |
     |  to_device(...)
     |
     |  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 is produced in C-order by default.
     |      This behavior is controlled by the ``order`` parameter.
     |
     |      .. versionadded:: 1.9.0
     |
     |      Parameters
     |      ----------
     |      order : {'C', 'F', 'A'}, optional
     |          Controls the memory layout of the bytes object. 'C' means C-order,
     |          'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
     |          Fortran contiguous, 'C' otherwise. Default is 'C'.
     |
     |      Returns
     |      -------
     |      s : bytes
     |          Python bytes exhibiting a copy of `a`'s raw data.
     |
     |      See also
     |      --------
     |      frombuffer
     |          Inverse of this operation, construct a 1-dimensional array from Python
     |          bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
     |      >>> x.tobytes()
     |      b'\x00\x00\x01\x00\x02\x00\x03\x00'
     |      >>> x.tobytes('C') == x.tobytes()
     |      True
     |      >>> x.tobytes('F')
     |      b'\x00\x00\x02\x00\x01\x00\x03\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 or Path
     |          An open file object, or a string containing a filename.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |      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.
     |
     |      When fid is a file object, array contents are directly written to the
     |      file, bypassing the file object's ``write`` method. As a result, tofile
     |      cannot be used with files objects supporting compression (e.g., GzipFile)
     |      or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
     |
     |  tolist(...)
     |      a.tolist()
     |
     |      Return the array as an ``a.ndim``-levels deep nested list of Python scalars.
     |
     |      Return a copy of the array data as a (nested) Python list.
     |      Data items are converted to the nearest compatible builtin Python type, via
     |      the `~numpy.ndarray.item` function.
     |
     |      If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will
     |      not be a list at all, but a simple Python scalar.
     |
     |      Parameters
     |      ----------
     |      none
     |
     |      Returns
     |      -------
     |      y : object, or list of object, or list of list of object, or ...
     |          The possibly nested list of array elements.
     |
     |      Notes
     |      -----
     |      The array may be recreated via ``a = np.array(a.tolist())``, although this
     |      may sometimes lose precision.
     |
     |      Examples
     |      --------
     |      For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,
     |      except that ``tolist`` changes numpy scalars to Python scalars:
     |
     |      >>> import numpy as np
     |      >>> a = np.uint32([1, 2])
     |      >>> a_list = list(a)
     |      >>> a_list
     |      [1, 2]
     |      >>> type(a_list[0])
     |      <class 'numpy.uint32'>
     |      >>> a_tolist = a.tolist()
     |      >>> a_tolist
     |      [1, 2]
     |      >>> type(a_tolist[0])
     |      <class 'int'>
     |
     |      Additionally, for a 2D array, ``tolist`` applies recursively:
     |
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> list(a)
     |      [array([1, 2]), array([3, 4])]
     |      >>> a.tolist()
     |      [[1, 2], [3, 4]]
     |
     |      The base case for this recursion is a 0D array:
     |
     |      >>> a = np.array(1)
     |      >>> list(a)
     |      Traceback (most recent call last):
     |        ...
     |      TypeError: iteration over a 0-d array
     |      >>> a.tolist()
     |      1
     |
     |  tostring(...)
     |      a.tostring(order='C')
     |
     |      A compatibility alias for `~ndarray.tobytes`, with exactly the same
     |      behavior.
     |
     |      Despite its name, it returns :class:`bytes` not :class:`str`\ s.
     |
     |      .. deprecated:: 1.19.0
     |
     |  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.
     |
     |      Refer to `numpy.transpose` for full documentation.
     |
     |      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 that the
     |         array's `i`-th axis becomes the transposed array'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
     |      -------
     |      p : ndarray
     |          View of the array with its axes suitably permuted.
     |
     |      See Also
     |      --------
     |      transpose : Equivalent function.
     |      ndarray.T : Array property returning the array transposed.
     |      ndarray.reshape : Give a new shape to an array without changing its data.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.transpose()
     |      array([1, 2, 3, 4])
     |
     |  var(...)
     |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
     |
     |      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][, type])
     |
     |      New view of array with the same data.
     |
     |      .. note::
     |          Passing None for ``dtype`` is different from omitting the parameter,
     |          since the former invokes ``dtype(None)`` which is an alias for
     |          ``dtype('float64')``.
     |
     |      Parameters
     |      ----------
     |      dtype : data-type or ndarray sub-class, optional
     |          Data-type descriptor of the returned view, e.g., float32 or int16.
     |          Omitting it 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, omission
     |          of the parameter 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 last axis of ``a`` must be
     |      contiguous. This axis will be resized in the result.
     |
     |      .. versionchanged:: 1.23.0
     |         Only the last axis needs to be contiguous. Previously, the entire array
     |         had to be C-contiguous.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
     |
     |      Viewing array data using a different type and dtype:
     |
     |      >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
     |      >>> y = x.view(dtype=nonneg, type=np.recarray)
     |      >>> x["a"]
     |      array([-1], dtype=int8)
     |      >>> y.a
     |      array([255], dtype=uint8)
     |
     |      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
     |      >>> x
     |      array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      Using a view to convert an array to a recarray:
     |
     |      >>> z = x.view(np.recarray)
     |      >>> z.a
     |      array([1, 3], dtype=int8)
     |
     |      Views share data:
     |
     |      >>> x[0] = (9, 10)
     |      >>> z[0]
     |      np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      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[:, ::2]
     |      >>> y
     |      array([[1, 3],
     |             [4, 6]], dtype=int16)
     |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      Traceback (most recent call last):
     |          ...
     |      ValueError: To change to a dtype of a different size, the last axis must be contiguous
     |      >>> z = y.copy()
     |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      array([[(1, 3)],
     |             [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
     |
     |      However, views that change dtype are totally fine for arrays with a
     |      contiguous last axis, even if the rest of the axes are not C-contiguous:
     |
     |      >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
     |      >>> x.transpose(1, 0, 2).view(np.int16)
     |      array([[[ 256,  770],
     |              [3340, 3854]],
     |      <BLANKLINE>
     |             [[1284, 1798],
     |              [4368, 4882]],
     |      <BLANKLINE>
     |             [[2312, 2826],
     |              [5396, 5910]]], dtype=int16)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from ndarray:
     |
     |  __class_getitem__(...)
     |      a.__class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.ndarray` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.ndarray` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.ndarray[Any, np.dtype[Any]]
     |      numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |      numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
     |                          w.r.t. its `dtype.type <numpy.dtype.type>`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ndarray:
     |
     |  T
     |      View of the transposed array.
     |
     |      Same as ``self.transpose()``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.T
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.T
     |      array([1, 2, 3, 4])
     |
     |      See Also
     |      --------
     |      transpose
     |
     |  __array_interface__
     |      Array protocol: Python side.
     |
     |  __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:
     |
     |      >>> import numpy as np
     |      >>> 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):
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.data
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.shape
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.strides
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.data_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.shape_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.strides_as
     |          :noindex:
     |
     |      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 numpy as np
     |      >>> import ctypes
     |      >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
     |      >>> x
     |      array([[0, 1],
     |             [2, 3]], dtype=int32)
     |      >>> x.ctypes.data
     |      31962608 # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
     |      <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
     |      c_uint(0)
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
     |      c_ulong(4294967296)
     |      >>> x.ctypes.shape
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
     |      >>> x.ctypes.strides
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
     |
     |  data
     |      Python buffer object pointing to the start of the array's data.
     |
     |  device
     |
     |  dtype
     |      Data-type of the array's elements.
     |
     |      .. warning::
     |
     |          Setting ``arr.dtype`` is discouraged and may be deprecated in the
     |          future.  Setting will replace the ``dtype`` without modifying the
     |          memory (see also `ndarray.view` and `ndarray.astype`).
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      d : numpy dtype object
     |
     |      See Also
     |      --------
     |      ndarray.astype : Cast the values contained in the array to a new data-type.
     |      ndarray.view : Create a view of the same data but a different data-type.
     |      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.
     |      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, 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:
     |
     |      - 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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)
     |      <class '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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.sqrt([1+0j, 0+1j])
     |      >>> x.imag
     |      array([ 0.        ,  0.70710678])
     |      >>> x.imag.dtype
     |      dtype('float64')
     |
     |  itemset
     |
     |  itemsize
     |      Length of one array element in bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1,2,3], dtype=np.float64)
     |      >>> x.itemsize
     |      8
     |      >>> x = np.array([1,2,3], dtype=np.complex128)
     |      >>> x.itemsize
     |      16
     |
     |  mT
     |      View of the matrix transposed array.
     |
     |      The matrix transpose is the transpose of the last two dimensions, even
     |      if the array is of higher dimension.
     |
     |      .. versionadded:: 2.0
     |
     |      Raises
     |      ------
     |      ValueError
     |          If the array is of dimension less than 2.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.mT
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.arange(8).reshape((2, 2, 2))
     |      >>> a
     |      array([[[0, 1],
     |              [2, 3]],
     |      <BLANKLINE>
     |             [[4, 5],
     |              [6, 7]]])
     |      >>> a.mT
     |      array([[[0, 2],
     |              [1, 3]],
     |      <BLANKLINE>
     |             [[4, 6],
     |              [5, 7]]])
     |
     |  nbytes
     |      Total bytes consumed by the elements of the array.
     |
     |      Notes
     |      -----
     |      Does not include memory consumed by non-element attributes of the
     |      array object.
     |
     |      See Also
     |      --------
     |      sys.getsizeof
     |          Memory consumed by the object itself without parents in case view.
     |          This does include memory consumed by non-element attributes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> x.ndim
     |      1
     |      >>> y = np.zeros((2, 3, 4))
     |      >>> y.ndim
     |      3
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the array.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |
     |      .. warning::
     |
     |          Setting ``arr.shape`` is discouraged and may be deprecated in the
     |          future.  Using `ndarray.reshape` is the preferred approach.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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 in-place modification. Use
     |      `.reshape()` to make a copy with the desired shape.
     |
     |      See Also
     |      --------
     |      numpy.shape : Equivalent getter function.
     |      numpy.reshape : Function similar to setting ``shape``.
     |      ndarray.reshape : Method similar to setting ``shape``.
     |
     |  size
     |      Number of elements in the array.
     |
     |      Equal to ``np.prod(a.shape)``, i.e., the product of the array's
     |      dimensions.
     |
     |      Notes
     |      -----
     |      `a.size` returns a standard arbitrary precision Python integer. This
     |      may not be the case with other methods of obtaining the same value
     |      (like the suggested ``np.prod(a.shape)``, which returns an instance
     |      of ``np.int_``), and may be relevant if the value is used further in
     |      calculations that may overflow a fixed size integer type.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      :ref:`arrays.ndarray`.
     |
     |      .. warning::
     |
     |          Setting ``arr.strides`` is discouraged and may be deprecated in the
     |          future.  `numpy.lib.stride_tricks.as_strided` should be preferred
     |          to create a new view of the same data in a safer way.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> 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 ndarray:
     |
     |  __hash__ = None

    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.
     |  numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
     |                         w.r.t. its `dtype.type <numpy.dtype.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:
     |
     |  >>> import numpy as np
     |  >>> np.ndarray(shape=(2,2), dtype=float, order='F')
     |  array([[0.0e+000, 0.0e+000], # random
     |         [     nan, 2.5e-323]])
     |
     |  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], *, copy=None)
     |
     |      For ``dtype`` parameter it returns a new reference to self if
     |      ``dtype`` is not given or it matches array's data type.
     |      A new array of provided data type is returned if ``dtype``
     |      is different from the current data type of the array.
     |      For ``copy`` parameter it returns a new reference to self if
     |      ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype``
     |      parameter. The method returns a new array for ``copy=True``, regardless of
     |      ``dtype`` parameter.
     |
     |      A more detailed explanation of the ``__array__`` interface
     |      can be found in :ref:`dunder_array.interface`.
     |
     |  __array_finalize__(...)
     |      a.__array_finalize__(obj, /)
     |
     |      Present so subclasses can call super. Does nothing.
     |
     |  __array_function__(...)
     |
     |  __array_namespace__(...)
     |
     |  __array_ufunc__(...)
     |
     |  __array_wrap__(...)
     |      a.__array_wrap__(array[, context], /)
     |
     |      Returns a view of `array` with the same type as self.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __contains__(self, key, /)
     |      Return bool(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, /)
     |
     |      Used if :func:`copy.deepcopy` is called on an array.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __dlpack__(...)
     |      a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __dlpack_device__(...)
     |      a.__dlpack_device__()
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      Default object formatter.
     |
     |      Return str(self) if format_spec is empty. Raise TypeError otherwise.
     |
     |  __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.
     |
     |  __reduce_ex__(...)
     |      Helper for pickle.
     |
     |  __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__(...)
     |      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, *, where=True)
     |
     |      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, *, where=True)
     |
     |      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, *, keepdims=False)
     |
     |      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, *, keepdims=False)
     |
     |      Return indices of the minimum values along the given axis.
     |
     |      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=None, 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
     |      -----
     |      .. versionchanged:: 1.17.0
     |         Casting between a simple data type and a structured one is possible only
     |         for "unsafe" casting.  Casting to multiple fields is allowed, but
     |         casting from multiple fields is not.
     |
     |      .. versionchanged:: 1.9.0
     |         Casting from numeric to string types in 'safe' casting mode requires
     |         that the string dtype length is long enough to store the max
     |         integer/float value converted.
     |
     |      Raises
     |      ------
     |      ComplexWarning
     |          When casting from complex to float or int. To avoid this,
     |          one should use ``a.real.astype(t)``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |      Arrays of byte-strings are not swapped. The real and imaginary
     |      parts of a complex number are swapped individually.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
     |      >>> list(map(hex, A))
     |      ['0x1', '0x100', '0x2233']
     |      >>> A.byteswap(inplace=True)
     |      array([  256,     1, 13090], dtype=int16)
     |      >>> list(map(hex, A))
     |      ['0x100', '0x1', '0x3322']
     |
     |      Arrays of byte-strings are not swapped
     |
     |      >>> A = np.array([b'ceg', b'fac'])
     |      >>> A.byteswap()
     |      array([b'ceg', b'fac'], dtype='|S3')
     |
     |      ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with
     |      the same values but different representation in memory
     |
     |      >>> A = np.array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
     |             0, 0], dtype=uint8)
     |      >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
     |      array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
     |             0, 3], dtype=uint8)
     |
     |  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, **kwargs)
     |
     |      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, and this function always passes sub-classes through.)
     |
     |      See also
     |      --------
     |      numpy.copy : Similar function with different default behavior
     |      numpy.copyto
     |
     |      Notes
     |      -----
     |      This function is the preferred method for creating an array copy.  The
     |      function :func:`numpy.copy` is similar, but it defaults to using order 'K',
     |      and will not pass sub-classes through by default.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |
     |      For arrays containing Python objects (e.g. dtype=object),
     |      the copy is a shallow one. The new array will contain the
     |      same object which may lead to surprises if that object can
     |      be modified (is mutable):
     |
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> b = a.copy()
     |      >>> b[2][0] = 10
     |      >>> a
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |
     |      To ensure all elements within an ``object`` array are copied,
     |      use `copy.deepcopy`:
     |
     |      >>> import copy
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> c = copy.deepcopy(a)
     |      >>> c[2][0] = 10
     |      >>> c
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |      >>> a
     |      array([1, 'm', list([2, 3, 4])], dtype=object)
     |
     |  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(...)
     |
     |  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 or Path
     |          A string naming the dump file.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |  dumps(...)
     |      a.dumps()
     |
     |      Returns the pickle of the array as a string.
     |      pickle.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
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([1, 2])
     |      >>> a.fill(0)
     |      >>> a
     |      array([0, 0])
     |      >>> a = np.empty(2)
     |      >>> a.fill(1)
     |      >>> a
     |      array([1.,  1.])
     |
     |      Fill expects a scalar value and always behaves the same as assigning
     |      to a single array element.  The following is a rare example where this
     |      distinction is important:
     |
     |      >>> a = np.array([None, None], dtype=object)
     |      >>> a[0] = np.array(3)
     |      >>> a
     |      array([array(3), None], dtype=object)
     |      >>> a.fill(np.array(3))
     |      >>> a
     |      array([array(3), array(3)], dtype=object)
     |
     |      Where other forms of assignments will unpack the array being assigned:
     |
     |      >>> a[...] = np.array(3)
     |      >>> a
     |      array([3, 3], dtype=object)
     |
     |  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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> np.random.seed(123)
     |      >>> x = np.random.randint(9, size=(3, 3))
     |      >>> x
     |      array([[2, 2, 6],
     |             [1, 3, 6],
     |             [1, 0, 1]])
     |      >>> x.item(3)
     |      1
     |      >>> x.item(7)
     |      0
     |      >>> x.item((0, 1))
     |      2
     |      >>> x.item((2, 2))
     |      1
     |
     |      For an array with object dtype, elements are returned as-is.
     |
     |      >>> a = np.array([np.int64(1)], dtype=object)
     |      >>> a.item() #return np.int64
     |      np.int64(1)
     |
     |  max(...)
     |      a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
     |
     |      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, *, where=True)
     |
     |      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, initial=<no value>, where=True)
     |
     |      Return the minimum along a given axis.
     |
     |      Refer to `numpy.amin` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.amin : equivalent function
     |
     |  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)
     |
     |      Partially sorts the elements in the array in such a way that the value of
     |      the element in k-th position is in the position it would be in a sorted
     |      array. In the output array, all elements smaller than the k-th element
     |      are located to the left of this element and all equal or greater are
     |      located to its right. The ordering of the elements in the two partitions
     |      on the either side of the k-th element in the output array 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 of 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.
     |
     |          .. deprecated:: 1.22.0
     |              Passing booleans as index is deprecated.
     |      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 to 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 partitioned copy of an array.
     |      argpartition : Indirect partition.
     |      sort : Full sort.
     |
     |      Notes
     |      -----
     |      See ``np.partition`` for notes on the different algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([3, 4, 2, 1])
     |      >>> a.partition(3)
     |      >>> a
     |      array([2, 1, 3, 4]) # may vary
     |
     |      >>> a.partition((1, 3))
     |      >>> a
     |      array([1, 2, 3, 4])
     |
     |  prod(...)
     |      a.prod(axis=None, dtype=None, out=None, keepdims=False,
     |          initial=1, where=True)
     |
     |      Return the product of the array elements over the given axis
     |
     |      Refer to `numpy.prod` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.prod : 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', copy=None)
     |
     |      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:
     |
     |      >>> import numpy as np
     |
     |      >>> 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 references or is 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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]], dtype=int32)
     |      >>> x
     |      array([[1.0e+000, 1.5e-323, 1.5e-323],
     |             [1.5e-323, 1.0e+000, 1.5e-323],
     |             [1.5e-323, 1.5e-323, 1.0e+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,
     |      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 flag 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 three of which can be changed by the user:
     |      WRITEBACKIFCOPY, 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);
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> y = np.array([[3, 1, 7],
     |      ...               [2, 0, 0],
     |      ...               [8, 5, 9]])
     |      >>> 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
     |      >>> y.setflags(write=0, align=0)
     |      >>> y.flags
     |        C_CONTIGUOUS : True
     |        F_CONTIGUOUS : False
     |        OWNDATA : True
     |        WRITEABLE : False
     |        ALIGNED : False
     |        WRITEBACKIFCOPY : 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=None, order=None)
     |
     |      Sort an array in-place. Refer to `numpy.sort` for full documentation.
     |
     |      Parameters
     |      ----------
     |      axis : int, optional
     |          Axis along which to sort. Default is -1, which means sort along the
     |          last axis.
     |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
     |          Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
     |          and 'mergesort' use timsort under the covers and, in general, the
     |          actual implementation will vary with datatype. The 'mergesort' option
     |          is retained for backwards compatibility.
     |
     |          .. versionchanged:: 1.15.0
     |             The 'stable' option was added.
     |
     |      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.
     |      numpy.argsort : Indirect sort.
     |      numpy.lexsort : Indirect stable sort on multiple keys.
     |      numpy.searchsorted : Find elements in sorted array.
     |      numpy.partition: Partial sort.
     |
     |      Notes
     |      -----
     |      See `numpy.sort` for notes on the different sorting algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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([(b'c', 1), (b'a', 2)],
     |            dtype=[('x', 'S1'), ('y', '<i8')])
     |
     |  squeeze(...)
     |      a.squeeze(axis=None)
     |
     |      Remove axes of length one from `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, *, where=True)
     |
     |      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, initial=0, where=True)
     |
     |      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
     |
     |  to_device(...)
     |
     |  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 is produced in C-order by default.
     |      This behavior is controlled by the ``order`` parameter.
     |
     |      .. versionadded:: 1.9.0
     |
     |      Parameters
     |      ----------
     |      order : {'C', 'F', 'A'}, optional
     |          Controls the memory layout of the bytes object. 'C' means C-order,
     |          'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
     |          Fortran contiguous, 'C' otherwise. Default is 'C'.
     |
     |      Returns
     |      -------
     |      s : bytes
     |          Python bytes exhibiting a copy of `a`'s raw data.
     |
     |      See also
     |      --------
     |      frombuffer
     |          Inverse of this operation, construct a 1-dimensional array from Python
     |          bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
     |      >>> x.tobytes()
     |      b'\x00\x00\x01\x00\x02\x00\x03\x00'
     |      >>> x.tobytes('C') == x.tobytes()
     |      True
     |      >>> x.tobytes('F')
     |      b'\x00\x00\x02\x00\x01\x00\x03\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 or Path
     |          An open file object, or a string containing a filename.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |      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.
     |
     |      When fid is a file object, array contents are directly written to the
     |      file, bypassing the file object's ``write`` method. As a result, tofile
     |      cannot be used with files objects supporting compression (e.g., GzipFile)
     |      or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
     |
     |  tolist(...)
     |      a.tolist()
     |
     |      Return the array as an ``a.ndim``-levels deep nested list of Python scalars.
     |
     |      Return a copy of the array data as a (nested) Python list.
     |      Data items are converted to the nearest compatible builtin Python type, via
     |      the `~numpy.ndarray.item` function.
     |
     |      If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will
     |      not be a list at all, but a simple Python scalar.
     |
     |      Parameters
     |      ----------
     |      none
     |
     |      Returns
     |      -------
     |      y : object, or list of object, or list of list of object, or ...
     |          The possibly nested list of array elements.
     |
     |      Notes
     |      -----
     |      The array may be recreated via ``a = np.array(a.tolist())``, although this
     |      may sometimes lose precision.
     |
     |      Examples
     |      --------
     |      For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,
     |      except that ``tolist`` changes numpy scalars to Python scalars:
     |
     |      >>> import numpy as np
     |      >>> a = np.uint32([1, 2])
     |      >>> a_list = list(a)
     |      >>> a_list
     |      [1, 2]
     |      >>> type(a_list[0])
     |      <class 'numpy.uint32'>
     |      >>> a_tolist = a.tolist()
     |      >>> a_tolist
     |      [1, 2]
     |      >>> type(a_tolist[0])
     |      <class 'int'>
     |
     |      Additionally, for a 2D array, ``tolist`` applies recursively:
     |
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> list(a)
     |      [array([1, 2]), array([3, 4])]
     |      >>> a.tolist()
     |      [[1, 2], [3, 4]]
     |
     |      The base case for this recursion is a 0D array:
     |
     |      >>> a = np.array(1)
     |      >>> list(a)
     |      Traceback (most recent call last):
     |        ...
     |      TypeError: iteration over a 0-d array
     |      >>> a.tolist()
     |      1
     |
     |  tostring(...)
     |      a.tostring(order='C')
     |
     |      A compatibility alias for `~ndarray.tobytes`, with exactly the same
     |      behavior.
     |
     |      Despite its name, it returns :class:`bytes` not :class:`str`\ s.
     |
     |      .. deprecated:: 1.19.0
     |
     |  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.
     |
     |      Refer to `numpy.transpose` for full documentation.
     |
     |      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 that the
     |         array's `i`-th axis becomes the transposed array'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
     |      -------
     |      p : ndarray
     |          View of the array with its axes suitably permuted.
     |
     |      See Also
     |      --------
     |      transpose : Equivalent function.
     |      ndarray.T : Array property returning the array transposed.
     |      ndarray.reshape : Give a new shape to an array without changing its data.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.transpose()
     |      array([1, 2, 3, 4])
     |
     |  var(...)
     |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
     |
     |      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][, type])
     |
     |      New view of array with the same data.
     |
     |      .. note::
     |          Passing None for ``dtype`` is different from omitting the parameter,
     |          since the former invokes ``dtype(None)`` which is an alias for
     |          ``dtype('float64')``.
     |
     |      Parameters
     |      ----------
     |      dtype : data-type or ndarray sub-class, optional
     |          Data-type descriptor of the returned view, e.g., float32 or int16.
     |          Omitting it 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, omission
     |          of the parameter 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 last axis of ``a`` must be
     |      contiguous. This axis will be resized in the result.
     |
     |      .. versionchanged:: 1.23.0
     |         Only the last axis needs to be contiguous. Previously, the entire array
     |         had to be C-contiguous.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
     |
     |      Viewing array data using a different type and dtype:
     |
     |      >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
     |      >>> y = x.view(dtype=nonneg, type=np.recarray)
     |      >>> x["a"]
     |      array([-1], dtype=int8)
     |      >>> y.a
     |      array([255], dtype=uint8)
     |
     |      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
     |      >>> x
     |      array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      Using a view to convert an array to a recarray:
     |
     |      >>> z = x.view(np.recarray)
     |      >>> z.a
     |      array([1, 3], dtype=int8)
     |
     |      Views share data:
     |
     |      >>> x[0] = (9, 10)
     |      >>> z[0]
     |      np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      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[:, ::2]
     |      >>> y
     |      array([[1, 3],
     |             [4, 6]], dtype=int16)
     |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      Traceback (most recent call last):
     |          ...
     |      ValueError: To change to a dtype of a different size, the last axis must be contiguous
     |      >>> z = y.copy()
     |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      array([[(1, 3)],
     |             [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
     |
     |      However, views that change dtype are totally fine for arrays with a
     |      contiguous last axis, even if the rest of the axes are not C-contiguous:
     |
     |      >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
     |      >>> x.transpose(1, 0, 2).view(np.int16)
     |      array([[[ 256,  770],
     |              [3340, 3854]],
     |      <BLANKLINE>
     |             [[1284, 1798],
     |              [4368, 4882]],
     |      <BLANKLINE>
     |             [[2312, 2826],
     |              [5396, 5910]]], dtype=int16)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      a.__class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.ndarray` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.ndarray` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.ndarray[Any, np.dtype[Any]]
     |      numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |      numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
     |                          w.r.t. its `dtype.type <numpy.dtype.type>`.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  T
     |      View of the transposed array.
     |
     |      Same as ``self.transpose()``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.T
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.T
     |      array([1, 2, 3, 4])
     |
     |      See Also
     |      --------
     |      transpose
     |
     |  __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:
     |
     |      >>> import numpy as np
     |      >>> 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):
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.data
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.shape
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.strides
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.data_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.shape_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.strides_as
     |          :noindex:
     |
     |      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 numpy as np
     |      >>> import ctypes
     |      >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
     |      >>> x
     |      array([[0, 1],
     |             [2, 3]], dtype=int32)
     |      >>> x.ctypes.data
     |      31962608 # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
     |      <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
     |      c_uint(0)
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
     |      c_ulong(4294967296)
     |      >>> x.ctypes.shape
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
     |      >>> x.ctypes.strides
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
     |
     |  data
     |      Python buffer object pointing to the start of the array's data.
     |
     |  device
     |
     |  dtype
     |      Data-type of the array's elements.
     |
     |      .. warning::
     |
     |          Setting ``arr.dtype`` is discouraged and may be deprecated in the
     |          future.  Setting will replace the ``dtype`` without modifying the
     |          memory (see also `ndarray.view` and `ndarray.astype`).
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      d : numpy dtype object
     |
     |      See Also
     |      --------
     |      ndarray.astype : Cast the values contained in the array to a new data-type.
     |      ndarray.view : Create a view of the same data but a different data-type.
     |      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.
     |      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, 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:
     |
     |      - 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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)
     |      <class '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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.sqrt([1+0j, 0+1j])
     |      >>> x.imag
     |      array([ 0.        ,  0.70710678])
     |      >>> x.imag.dtype
     |      dtype('float64')
     |
     |  itemset
     |
     |  itemsize
     |      Length of one array element in bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1,2,3], dtype=np.float64)
     |      >>> x.itemsize
     |      8
     |      >>> x = np.array([1,2,3], dtype=np.complex128)
     |      >>> x.itemsize
     |      16
     |
     |  mT
     |      View of the matrix transposed array.
     |
     |      The matrix transpose is the transpose of the last two dimensions, even
     |      if the array is of higher dimension.
     |
     |      .. versionadded:: 2.0
     |
     |      Raises
     |      ------
     |      ValueError
     |          If the array is of dimension less than 2.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.mT
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.arange(8).reshape((2, 2, 2))
     |      >>> a
     |      array([[[0, 1],
     |              [2, 3]],
     |      <BLANKLINE>
     |             [[4, 5],
     |              [6, 7]]])
     |      >>> a.mT
     |      array([[[0, 2],
     |              [1, 3]],
     |      <BLANKLINE>
     |             [[4, 6],
     |              [5, 7]]])
     |
     |  nbytes
     |      Total bytes consumed by the elements of the array.
     |
     |      Notes
     |      -----
     |      Does not include memory consumed by non-element attributes of the
     |      array object.
     |
     |      See Also
     |      --------
     |      sys.getsizeof
     |          Memory consumed by the object itself without parents in case view.
     |          This does include memory consumed by non-element attributes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> x.ndim
     |      1
     |      >>> y = np.zeros((2, 3, 4))
     |      >>> y.ndim
     |      3
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the array.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |
     |      .. warning::
     |
     |          Setting ``arr.shape`` is discouraged and may be deprecated in the
     |          future.  Using `ndarray.reshape` is the preferred approach.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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 in-place modification. Use
     |      `.reshape()` to make a copy with the desired shape.
     |
     |      See Also
     |      --------
     |      numpy.shape : Equivalent getter function.
     |      numpy.reshape : Function similar to setting ``shape``.
     |      ndarray.reshape : Method similar to setting ``shape``.
     |
     |  size
     |      Number of elements in the array.
     |
     |      Equal to ``np.prod(a.shape)``, i.e., the product of the array's
     |      dimensions.
     |
     |      Notes
     |      -----
     |      `a.size` returns a standard arbitrary precision Python integer. This
     |      may not be the case with other methods of obtaining the same value
     |      (like the suggested ``np.prod(a.shape)``, which returns an instance
     |      of ``np.int_``), and may be relevant if the value is used further in
     |      calculations that may overflow a fixed size integer type.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      :ref:`arrays.ndarray`.
     |
     |      .. warning::
     |
     |          Setting ``arr.strides`` is discouraged and may be deprecated in the
     |          future.  `numpy.lib.stride_tricks.as_strided` should be preferred
     |          to create a new view of the same data in a safer way.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> 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 ndenumerate(builtins.object)
     |  ndenumerate(arr)
     |
     |  Multidimensional index iterator.
     |
     |  Return an iterator yielding pairs of array coordinates and values.
     |
     |  Parameters
     |  ----------
     |  arr : ndarray
     |    Input array.
     |
     |  See Also
     |  --------
     |  ndindex, flatiter
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> a = np.array([[1, 2], [3, 4]])
     |  >>> for index, x in np.ndenumerate(a):
     |  ...     print(index, x)
     |  (0, 0) 1
     |  (0, 1) 2
     |  (1, 0) 3
     |  (1, 1) 4
     |
     |  Methods defined here:
     |
     |  __init__(self, arr) from numpy.lib._index_tricks_impl.ndenumerate
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self) from numpy.lib._index_tricks_impl.ndenumerate
     |
     |  __next__(self) from numpy.lib._index_tricks_impl.ndenumerate
     |      Standard iterator method, returns the index tuple and array value.
     |
     |      Returns
     |      -------
     |      coords : tuple of ints
     |          The indices of the current iteration.
     |      val : scalar
     |          The array element of the current iteration.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ndindex(builtins.object)
     |  ndindex(*shape)
     |
     |  An N-dimensional iterator object to index arrays.
     |
     |  Given the shape of an array, an `ndindex` instance iterates over
     |  the N-dimensional index of the array. At each iteration a tuple
     |  of indices is returned, the last dimension is iterated over first.
     |
     |  Parameters
     |  ----------
     |  shape : ints, or a single tuple of ints
     |      The size of each dimension of the array can be passed as
     |      individual parameters or as the elements of a tuple.
     |
     |  See Also
     |  --------
     |  ndenumerate, flatiter
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |
     |  Dimensions as individual arguments
     |
     |  >>> for index in np.ndindex(3, 2, 1):
     |  ...     print(index)
     |  (0, 0, 0)
     |  (0, 1, 0)
     |  (1, 0, 0)
     |  (1, 1, 0)
     |  (2, 0, 0)
     |  (2, 1, 0)
     |
     |  Same dimensions - but in a tuple ``(3, 2, 1)``
     |
     |  >>> for index in np.ndindex((3, 2, 1)):
     |  ...     print(index)
     |  (0, 0, 0)
     |  (0, 1, 0)
     |  (1, 0, 0)
     |  (1, 1, 0)
     |  (2, 0, 0)
     |  (2, 1, 0)
     |
     |  Methods defined here:
     |
     |  __init__(self, *shape) from numpy.lib._index_tricks_impl.ndindex
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self) from numpy.lib._index_tricks_impl.ndindex
     |
     |  __next__(self) from numpy.lib._index_tricks_impl.ndindex
     |      Standard iterator method, updates the index and returns the index
     |      tuple.
     |
     |      Returns
     |      -------
     |      val : tuple of ints
     |          Returns a tuple containing the indices of the current
     |          iteration.
     |
     |  ndincr(self) from numpy.lib._index_tricks_impl.ndindex
     |      Increment the multi-dimensional index by one.
     |
     |      This method is for backward compatibility only: do not use.
     |
     |      .. deprecated:: 1.20.0
     |          This method has been advised against since numpy 1.8.0, but only
     |          started emitting DeprecationWarning as of this version.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class nditer(builtins.object)
     |  nditer(op, flags=None, op_flags=None, op_dtypes=None, order='K',
     |      casting='safe', op_axes=None, itershape=None, buffersize=0)
     |
     |  Efficient multi-dimensional iterator object to iterate over arrays.
     |  To get started using this object, see the
     |  :ref:`introductory guide to array iteration <arrays.nditer>`.
     |
     |  Parameters
     |  ----------
     |  op : ndarray or sequence of array_like
     |      The array(s) to iterate over.
     |
     |  flags : sequence of str, optional
     |        Flags to control the behavior of the iterator.
     |
     |        * ``buffered`` enables buffering when required.
     |        * ``c_index`` causes a C-order index to be tracked.
     |        * ``f_index`` causes a Fortran-order index to be tracked.
     |        * ``multi_index`` causes a multi-index, or a tuple of indices
     |          with one per iteration dimension, to be tracked.
     |        * ``common_dtype`` causes all the operands to be converted to
     |          a common data type, with copying or buffering as necessary.
     |        * ``copy_if_overlap`` causes the iterator to determine if read
     |          operands have overlap with write operands, and make temporary
     |          copies as necessary to avoid overlap. False positives (needless
     |          copying) are possible in some cases.
     |        * ``delay_bufalloc`` delays allocation of the buffers until
     |          a reset() call is made. Allows ``allocate`` operands to
     |          be initialized before their values are copied into the buffers.
     |        * ``external_loop`` causes the ``values`` given to be
     |          one-dimensional arrays with multiple values instead of
     |          zero-dimensional arrays.
     |        * ``grow_inner`` allows the ``value`` array sizes to be made
     |          larger than the buffer size when both ``buffered`` and
     |          ``external_loop`` is used.
     |        * ``ranged`` allows the iterator to be restricted to a sub-range
     |          of the iterindex values.
     |        * ``refs_ok`` enables iteration of reference types, such as
     |          object arrays.
     |        * ``reduce_ok`` enables iteration of ``readwrite`` operands
     |          which are broadcasted, also known as reduction operands.
     |        * ``zerosize_ok`` allows `itersize` to be zero.
     |  op_flags : list of list of str, optional
     |        This is a list of flags for each operand. At minimum, one of
     |        ``readonly``, ``readwrite``, or ``writeonly`` must be specified.
     |
     |        * ``readonly`` indicates the operand will only be read from.
     |        * ``readwrite`` indicates the operand will be read from and written to.
     |        * ``writeonly`` indicates the operand will only be written to.
     |        * ``no_broadcast`` prevents the operand from being broadcasted.
     |        * ``contig`` forces the operand data to be contiguous.
     |        * ``aligned`` forces the operand data to be aligned.
     |        * ``nbo`` forces the operand data to be in native byte order.
     |        * ``copy`` allows a temporary read-only copy if required.
     |        * ``updateifcopy`` allows a temporary read-write copy if required.
     |        * ``allocate`` causes the array to be allocated if it is None
     |          in the ``op`` parameter.
     |        * ``no_subtype`` prevents an ``allocate`` operand from using a subtype.
     |        * ``arraymask`` indicates that this operand is the mask to use
     |          for selecting elements when writing to operands with the
     |          'writemasked' flag set. The iterator does not enforce this,
     |          but when writing from a buffer back to the array, it only
     |          copies those elements indicated by this mask.
     |        * ``writemasked`` indicates that only elements where the chosen
     |          ``arraymask`` operand is True will be written to.
     |        * ``overlap_assume_elementwise`` can be used to mark operands that are
     |          accessed only in the iterator order, to allow less conservative
     |          copying when ``copy_if_overlap`` is present.
     |  op_dtypes : dtype or tuple of dtype(s), optional
     |      The required data type(s) of the operands. If copying or buffering
     |      is enabled, the data will be converted to/from their original types.
     |  order : {'C', 'F', 'A', 'K'}, optional
     |      Controls the iteration order. '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. This also
     |      affects the element memory order of ``allocate`` operands, as they
     |      are allocated to be compatible with iteration order.
     |      Default is 'K'.
     |  casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
     |      Controls what kind of data casting may occur when making a copy
     |      or buffering.  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.
     |  op_axes : list of list of ints, optional
     |      If provided, is a list of ints or None for each operands.
     |      The list of axes for an operand is a mapping from the dimensions
     |      of the iterator to the dimensions of the operand. A value of
     |      -1 can be placed for entries, causing that dimension to be
     |      treated as `newaxis`.
     |  itershape : tuple of ints, optional
     |      The desired shape of the iterator. This allows ``allocate`` operands
     |      with a dimension mapped by op_axes not corresponding to a dimension
     |      of a different operand to get a value not equal to 1 for that
     |      dimension.
     |  buffersize : int, optional
     |      When buffering is enabled, controls the size of the temporary
     |      buffers. Set to 0 for the default value.
     |
     |  Attributes
     |  ----------
     |  dtypes : tuple of dtype(s)
     |      The data types of the values provided in `value`. This may be
     |      different from the operand data types if buffering is enabled.
     |      Valid only before the iterator is closed.
     |  finished : bool
     |      Whether the iteration over the operands is finished or not.
     |  has_delayed_bufalloc : bool
     |      If True, the iterator was created with the ``delay_bufalloc`` flag,
     |      and no reset() function was called on it yet.
     |  has_index : bool
     |      If True, the iterator was created with either the ``c_index`` or
     |      the ``f_index`` flag, and the property `index` can be used to
     |      retrieve it.
     |  has_multi_index : bool
     |      If True, the iterator was created with the ``multi_index`` flag,
     |      and the property `multi_index` can be used to retrieve it.
     |  index
     |      When the ``c_index`` or ``f_index`` flag was used, this property
     |      provides access to the index. Raises a ValueError if accessed
     |      and ``has_index`` is False.
     |  iterationneedsapi : bool
     |      Whether iteration requires access to the Python API, for example
     |      if one of the operands is an object array.
     |  iterindex : int
     |      An index which matches the order of iteration.
     |  itersize : int
     |      Size of the iterator.
     |  itviews
     |      Structured view(s) of `operands` in memory, matching the reordered
     |      and optimized iterator access pattern. Valid only before the iterator
     |      is closed.
     |  multi_index
     |      When the ``multi_index`` flag was used, this property
     |      provides access to the index. Raises a ValueError if accessed
     |      accessed and ``has_multi_index`` is False.
     |  ndim : int
     |      The dimensions of the iterator.
     |  nop : int
     |      The number of iterator operands.
     |  operands : tuple of operand(s)
     |      The array(s) to be iterated over. Valid only before the iterator is
     |      closed.
     |  shape : tuple of ints
     |      Shape tuple, the shape of the iterator.
     |  value
     |      Value of ``operands`` at current iteration. Normally, this is a
     |      tuple of array scalars, but if the flag ``external_loop`` is used,
     |      it is a tuple of one dimensional arrays.
     |
     |  Notes
     |  -----
     |  `nditer` supersedes `flatiter`.  The iterator implementation behind
     |  `nditer` is also exposed by the NumPy C API.
     |
     |  The Python exposure supplies two iteration interfaces, one which follows
     |  the Python iterator protocol, and another which mirrors the C-style
     |  do-while pattern.  The native Python approach is better in most cases, but
     |  if you need the coordinates or index of an iterator, use the C-style pattern.
     |
     |  Examples
     |  --------
     |  Here is how we might write an ``iter_add`` function, using the
     |  Python iterator protocol:
     |
     |  >>> import numpy as np
     |
     |  >>> def iter_add_py(x, y, out=None):
     |  ...     addop = np.add
     |  ...     it = np.nditer([x, y, out], [],
     |  ...                 [['readonly'], ['readonly'], ['writeonly','allocate']])
     |  ...     with it:
     |  ...         for (a, b, c) in it:
     |  ...             addop(a, b, out=c)
     |  ...         return it.operands[2]
     |
     |  Here is the same function, but following the C-style pattern:
     |
     |  >>> def iter_add(x, y, out=None):
     |  ...    addop = np.add
     |  ...    it = np.nditer([x, y, out], [],
     |  ...                [['readonly'], ['readonly'], ['writeonly','allocate']])
     |  ...    with it:
     |  ...        while not it.finished:
     |  ...            addop(it[0], it[1], out=it[2])
     |  ...            it.iternext()
     |  ...        return it.operands[2]
     |
     |  Here is an example outer product function:
     |
     |  >>> def outer_it(x, y, out=None):
     |  ...     mulop = np.multiply
     |  ...     it = np.nditer([x, y, out], ['external_loop'],
     |  ...             [['readonly'], ['readonly'], ['writeonly', 'allocate']],
     |  ...             op_axes=[list(range(x.ndim)) + [-1] * y.ndim,
     |  ...                      [-1] * x.ndim + list(range(y.ndim)),
     |  ...                      None])
     |  ...     with it:
     |  ...         for (a, b, c) in it:
     |  ...             mulop(a, b, out=c)
     |  ...         return it.operands[2]
     |
     |  >>> a = np.arange(2)+1
     |  >>> b = np.arange(3)+1
     |  >>> outer_it(a,b)
     |  array([[1, 2, 3],
     |         [2, 4, 6]])
     |
     |  Here is an example function which operates like a "lambda" ufunc:
     |
     |  >>> def luf(lamdaexpr, *args, **kwargs):
     |  ...    '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)'''
     |  ...    nargs = len(args)
     |  ...    op = (kwargs.get('out',None),) + args
     |  ...    it = np.nditer(op, ['buffered','external_loop'],
     |  ...            [['writeonly','allocate','no_broadcast']] +
     |  ...                            [['readonly','nbo','aligned']]*nargs,
     |  ...            order=kwargs.get('order','K'),
     |  ...            casting=kwargs.get('casting','safe'),
     |  ...            buffersize=kwargs.get('buffersize',0))
     |  ...    while not it.finished:
     |  ...        it[0] = lamdaexpr(*it[1:])
     |  ...        it.iternext()
     |  ...    return it.operands[0]
     |
     |  >>> a = np.arange(5)
     |  >>> b = np.ones(5)
     |  >>> luf(lambda i,j:i*i + j/2, a, b)
     |  array([  0.5,   1.5,   4.5,   9.5,  16.5])
     |
     |  If operand flags ``"writeonly"`` or ``"readwrite"`` are used the
     |  operands may be views into the original data with the
     |  `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a
     |  context manager or the `nditer.close` method must be called before
     |  using the result. The temporary data will be written back to the
     |  original data when the :meth:`~object.__exit__` function is called
     |  but not before:
     |
     |  >>> a = np.arange(6, dtype='i4')[::-2]
     |  >>> with np.nditer(a, [],
     |  ...        [['writeonly', 'updateifcopy']],
     |  ...        casting='unsafe',
     |  ...        op_dtypes=[np.dtype('f4')]) as i:
     |  ...    x = i.operands[0]
     |  ...    x[:] = [-1, -2, -3]
     |  ...    # a still unchanged here
     |  >>> a, x
     |  (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))
     |
     |  It is important to note that once the iterator is exited, dangling
     |  references (like `x` in the example) may or may not share data with
     |  the original data `a`. If writeback semantics were active, i.e. if
     |  `x.base.flags.writebackifcopy` is `True`, then exiting the iterator
     |  will sever the connection between `x` and `a`, writing to `x` will
     |  no longer write to `a`. If writeback semantics are not active, then
     |  `x.data` will still point at some part of `a.data`, and writing to
     |  one will affect the other.
     |
     |  Context management and the `close` method appeared in version 1.15.0.
     |
     |  Methods defined here:
     |
     |  __copy__(...)
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __enter__(...)
     |
     |  __exit__(...)
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __next__(self, /)
     |      Implement next(self).
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  close(...)
     |      close()
     |
     |      Resolve all writeback semantics in writeable operands.
     |
     |      .. versionadded:: 1.15.0
     |
     |      See Also
     |      --------
     |
     |      :ref:`nditer-context-manager`
     |
     |  copy(...)
     |      copy()
     |
     |      Get a copy of the iterator in its current state.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.arange(10)
     |      >>> y = x + 1
     |      >>> it = np.nditer([x, y])
     |      >>> next(it)
     |      (array(0), array(1))
     |      >>> it2 = it.copy()
     |      >>> next(it2)
     |      (array(1), array(2))
     |
     |  debug_print(...)
     |      debug_print()
     |
     |      Print the current state of the `nditer` instance and debug info to stdout.
     |
     |  enable_external_loop(...)
     |      enable_external_loop()
     |
     |      When the "external_loop" was not used during construction, but
     |      is desired, this modifies the iterator to behave as if the flag
     |      was specified.
     |
     |  iternext(...)
     |      iternext()
     |
     |      Check whether iterations are left, and perform a single internal iteration
     |      without returning the result.  Used in the C-style pattern do-while
     |      pattern.  For an example, see `nditer`.
     |
     |      Returns
     |      -------
     |      iternext : bool
     |          Whether or not there are iterations left.
     |
     |  remove_axis(...)
     |      remove_axis(i, /)
     |
     |      Removes axis `i` from the iterator. Requires that the flag "multi_index"
     |      be enabled.
     |
     |  remove_multi_index(...)
     |      remove_multi_index()
     |
     |      When the "multi_index" flag was specified, this removes it, allowing
     |      the internal iteration structure to be optimized further.
     |
     |  reset(...)
     |      reset()
     |
     |      Reset the iterator to its initial state.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  dtypes
     |
     |  finished
     |
     |  has_delayed_bufalloc
     |
     |  has_index
     |
     |  has_multi_index
     |
     |  index
     |
     |  iterationneedsapi
     |
     |  iterindex
     |
     |  iterrange
     |
     |  itersize
     |
     |  itviews
     |
     |  multi_index
     |
     |  ndim
     |
     |  nop
     |
     |  operands
     |      operands[`Slice`]
     |
     |      The array(s) to be iterated over. Valid only before the iterator is closed.
     |
     |  shape
     |
     |  value

    class number(generic)
     |  Abstract base class of all numeric scalar types.
     |
     |  Method resolution order:
     |      number
     |      generic
     |      builtins.object
     |
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    class object_(generic)
     |  Any Python object.
     |
     |  :Character code: ``'O'``
     |
     |  Method resolution order:
     |      object_
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __call__(self, /, *args, **kwargs)
     |      Call self as a function.
     |
     |  __contains__(self, key, /)
     |      Return bool(key in self).
     |
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |
     |  __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.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __iadd__(self, value, /)
     |      Implement self+=value.
     |
     |  __imul__(self, value, /)
     |      Implement self*=value.
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __release_buffer__(self, buffer, /)
     |      Release the buffer object that exposes the underlying memory of the object.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(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.
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class poly1d(builtins.object)
     |  poly1d(c_or_r, r=False, variable=None)
     |
     |  A one-dimensional polynomial class.
     |
     |  .. note::
     |     This forms part of the old polynomial API. Since version 1.4, the
     |     new polynomial API defined in `numpy.polynomial` is preferred.
     |     A summary of the differences can be found in the
     |     :doc:`transition guide </reference/routines.polynomials>`.
     |
     |  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`:
     |
     |  >>> import numpy as np
     |
     |  >>> 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]) # may vary
     |
     |  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) from numpy.lib._polynomial_impl.poly1d
     |
     |  __array__(self, t=None, copy=None) from numpy.lib._polynomial_impl.poly1d
     |
     |  __call__(self, val) from numpy.lib._polynomial_impl.poly1d
     |      Call self as a function.
     |
     |  __div__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __eq__(self, other) from numpy.lib._polynomial_impl.poly1d
     |      Return self==value.
     |
     |  __getitem__(self, val) from numpy.lib._polynomial_impl.poly1d
     |
     |  __init__(self, c_or_r, r=False, variable=None) from numpy.lib._polynomial_impl.poly1d
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self) from numpy.lib._polynomial_impl.poly1d
     |
     |  __len__(self) from numpy.lib._polynomial_impl.poly1d
     |
     |  __mul__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __ne__(self, other) from numpy.lib._polynomial_impl.poly1d
     |      Return self!=value.
     |
     |  __neg__(self) from numpy.lib._polynomial_impl.poly1d
     |
     |  __pos__(self) from numpy.lib._polynomial_impl.poly1d
     |
     |  __pow__(self, val) from numpy.lib._polynomial_impl.poly1d
     |
     |  __radd__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __rdiv__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __repr__(self) from numpy.lib._polynomial_impl.poly1d
     |      Return repr(self).
     |
     |  __rmul__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __rsub__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __rtruediv__ = __rdiv__(self, other)
     |
     |  __setitem__(self, key, val) from numpy.lib._polynomial_impl.poly1d
     |
     |  __str__(self) from numpy.lib._polynomial_impl.poly1d
     |      Return str(self).
     |
     |  __sub__(self, other) from numpy.lib._polynomial_impl.poly1d
     |
     |  __truediv__ = __div__(self, other)
     |
     |  deriv(self, m=1) from numpy.lib._polynomial_impl.poly1d
     |      Return a derivative of this polynomial.
     |
     |      Refer to `polyder` for full documentation.
     |
     |      See Also
     |      --------
     |      polyder : equivalent function
     |
     |  integ(self, m=1, k=0) from numpy.lib._polynomial_impl.poly1d
     |      Return an antiderivative (indefinite integral) of this polynomial.
     |
     |      Refer to `polyint` for full documentation.
     |
     |      See Also
     |      --------
     |      polyint : equivalent function
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  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 descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  c
     |      The polynomial coefficients
     |
     |  coef
     |      The polynomial coefficients
     |
     |  coefficients
     |      The polynomial coefficients
     |
     |  coeffs
     |      The polynomial coefficients
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

    class recarray(numpy.ndarray)
     |  recarray(shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C')
     |
     |  Construct an ndarray that allows field access using attributes.
     |
     |  Arrays may have a data-types containing fields, analogous
     |  to columns in a spread sheet.  An example is ``[(x, int), (y, float)]``,
     |  where each entry in the array is a pair of ``(int, float)``.  Normally,
     |  these attributes are accessed using dictionary lookups such as ``arr['x']``
     |  and ``arr['y']``.  Record arrays allow the fields to be accessed as members
     |  of the array, using ``arr.x`` and ``arr.y``.
     |
     |  Parameters
     |  ----------
     |  shape : tuple
     |      Shape of output array.
     |  dtype : data-type, optional
     |      The desired data-type.  By default, the data-type is determined
     |      from `formats`, `names`, `titles`, `aligned` and `byteorder`.
     |  formats : list of data-types, optional
     |      A list containing the data-types for the different columns, e.g.
     |      ``['i4', 'f8', 'i4']``.  `formats` does *not* support the new
     |      convention of using types directly, i.e. ``(int, float, int)``.
     |      Note that `formats` must be a list, not a tuple.
     |      Given that `formats` is somewhat limited, we recommend specifying
     |      `dtype` instead.
     |  names : tuple of str, optional
     |      The name of each column, e.g. ``('x', 'y', 'z')``.
     |  buf : buffer, optional
     |      By default, a new array is created of the given shape and data-type.
     |      If `buf` is specified and is an object exposing the buffer interface,
     |      the array will use the memory from the existing buffer.  In this case,
     |      the `offset` and `strides` keywords are available.
     |
     |  Other Parameters
     |  ----------------
     |  titles : tuple of str, optional
     |      Aliases for column names.  For example, if `names` were
     |      ``('x', 'y', 'z')`` and `titles` is
     |      ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then
     |      ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``.
     |  byteorder : {'<', '>', '='}, optional
     |      Byte-order for all fields.
     |  aligned : bool, optional
     |      Align the fields in memory as the C-compiler would.
     |  strides : tuple of ints, optional
     |      Buffer (`buf`) is interpreted according to these strides (strides
     |      define how many bytes each array element, row, column, etc.
     |      occupy in memory).
     |  offset : int, optional
     |      Start reading buffer (`buf`) from this offset onwards.
     |  order : {'C', 'F'}, optional
     |      Row-major (C-style) or column-major (Fortran-style) order.
     |
     |  Returns
     |  -------
     |  rec : recarray
     |      Empty array of the given shape and type.
     |
     |  See Also
     |  --------
     |  numpy.rec.fromrecords : Construct a record array from data.
     |  numpy.record : fundamental data-type for `recarray`.
     |  numpy.rec.format_parser : determine data-type from formats, names, titles.
     |
     |  Notes
     |  -----
     |  This constructor can be compared to ``empty``: it creates a new record
     |  array but does not fill it with data.  To create a record array from data,
     |  use one of the following methods:
     |
     |  1. Create a standard ndarray and convert it to a record array,
     |     using ``arr.view(np.recarray)``
     |  2. Use the `buf` keyword.
     |  3. Use `np.rec.fromrecords`.
     |
     |  Examples
     |  --------
     |  Create an array with two fields, ``x`` and ``y``:
     |
     |  >>> import numpy as np
     |  >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')])
     |  >>> x
     |  array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])
     |
     |  >>> x['x']
     |  array([1., 3.])
     |
     |  View the array as a record array:
     |
     |  >>> x = x.view(np.recarray)
     |
     |  >>> x.x
     |  array([1., 3.])
     |
     |  >>> x.y
     |  array([2, 4])
     |
     |  Create a new, empty record array:
     |
     |  >>> np.recarray((2,),
     |  ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP
     |  rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
     |         (3471280, 1.2134086255804012e-316, 0)],
     |        dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])
     |
     |  Method resolution order:
     |      recarray
     |      numpy.ndarray
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __array_finalize__(self, obj) from numpy._core.records.recarray
     |      a.__array_finalize__(obj, /)
     |
     |      Present so subclasses can call super. Does nothing.
     |
     |  __getattribute__(self, attr) from numpy._core.records.recarray
     |      Return getattr(self, name).
     |
     |  __getitem__(self, indx) from numpy._core.records.recarray
     |      Return self[key].
     |
     |  __repr__(self) from numpy._core.records.recarray
     |      Return repr(self).
     |
     |  __setattr__(self, attr, val) from numpy._core.records.recarray
     |      Implement setattr(self, name, value).
     |
     |  field(self, attr, val=None) from numpy._core.records.recarray
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(subtype, shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C') from numpy._core.records.recarray
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  ----------------------------------------------------------------------
     |  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], *, copy=None)
     |
     |      For ``dtype`` parameter it returns a new reference to self if
     |      ``dtype`` is not given or it matches array's data type.
     |      A new array of provided data type is returned if ``dtype``
     |      is different from the current data type of the array.
     |      For ``copy`` parameter it returns a new reference to self if
     |      ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype``
     |      parameter. The method returns a new array for ``copy=True``, regardless of
     |      ``dtype`` parameter.
     |
     |      A more detailed explanation of the ``__array__`` interface
     |      can be found in :ref:`dunder_array.interface`.
     |
     |  __array_function__(...)
     |
     |  __array_namespace__(...)
     |
     |  __array_ufunc__(...)
     |
     |  __array_wrap__(...)
     |      a.__array_wrap__(array[, context], /)
     |
     |      Returns a view of `array` with the same type as self.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __complex__(...)
     |
     |  __contains__(self, key, /)
     |      Return bool(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, /)
     |
     |      Used if :func:`copy.deepcopy` is called on an array.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __dlpack__(...)
     |      a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __dlpack_device__(...)
     |      a.__dlpack_device__()
     |
     |      DLPack Protocol: Part of the Array API.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      Default object formatter.
     |
     |      Return str(self) if format_spec is empty. Raise TypeError otherwise.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __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.
     |
     |  __reduce_ex__(...)
     |      Helper for pickle.
     |
     |  __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__(...)
     |      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, *, where=True)
     |
     |      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, *, where=True)
     |
     |      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, *, keepdims=False)
     |
     |      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, *, keepdims=False)
     |
     |      Return indices of the minimum values along the given axis.
     |
     |      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=None, 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
     |      -----
     |      .. versionchanged:: 1.17.0
     |         Casting between a simple data type and a structured one is possible only
     |         for "unsafe" casting.  Casting to multiple fields is allowed, but
     |         casting from multiple fields is not.
     |
     |      .. versionchanged:: 1.9.0
     |         Casting from numeric to string types in 'safe' casting mode requires
     |         that the string dtype length is long enough to store the max
     |         integer/float value converted.
     |
     |      Raises
     |      ------
     |      ComplexWarning
     |          When casting from complex to float or int. To avoid this,
     |          one should use ``a.real.astype(t)``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |      Arrays of byte-strings are not swapped. The real and imaginary
     |      parts of a complex number are swapped individually.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
     |      >>> list(map(hex, A))
     |      ['0x1', '0x100', '0x2233']
     |      >>> A.byteswap(inplace=True)
     |      array([  256,     1, 13090], dtype=int16)
     |      >>> list(map(hex, A))
     |      ['0x100', '0x1', '0x3322']
     |
     |      Arrays of byte-strings are not swapped
     |
     |      >>> A = np.array([b'ceg', b'fac'])
     |      >>> A.byteswap()
     |      array([b'ceg', b'fac'], dtype='|S3')
     |
     |      ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with
     |      the same values but different representation in memory
     |
     |      >>> A = np.array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
     |             0, 0], dtype=uint8)
     |      >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
     |      array([1, 2, 3])
     |      >>> A.view(np.uint8)
     |      array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
     |             0, 3], dtype=uint8)
     |
     |  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, **kwargs)
     |
     |      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, and this function always passes sub-classes through.)
     |
     |      See also
     |      --------
     |      numpy.copy : Similar function with different default behavior
     |      numpy.copyto
     |
     |      Notes
     |      -----
     |      This function is the preferred method for creating an array copy.  The
     |      function :func:`numpy.copy` is similar, but it defaults to using order 'K',
     |      and will not pass sub-classes through by default.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |
     |      For arrays containing Python objects (e.g. dtype=object),
     |      the copy is a shallow one. The new array will contain the
     |      same object which may lead to surprises if that object can
     |      be modified (is mutable):
     |
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> b = a.copy()
     |      >>> b[2][0] = 10
     |      >>> a
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |
     |      To ensure all elements within an ``object`` array are copied,
     |      use `copy.deepcopy`:
     |
     |      >>> import copy
     |      >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
     |      >>> c = copy.deepcopy(a)
     |      >>> c[2][0] = 10
     |      >>> c
     |      array([1, 'm', list([10, 3, 4])], dtype=object)
     |      >>> a
     |      array([1, 'm', list([2, 3, 4])], dtype=object)
     |
     |  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(...)
     |
     |  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 or Path
     |          A string naming the dump file.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |  dumps(...)
     |      a.dumps()
     |
     |      Returns the pickle of the array as a string.
     |      pickle.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
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([1, 2])
     |      >>> a.fill(0)
     |      >>> a
     |      array([0, 0])
     |      >>> a = np.empty(2)
     |      >>> a.fill(1)
     |      >>> a
     |      array([1.,  1.])
     |
     |      Fill expects a scalar value and always behaves the same as assigning
     |      to a single array element.  The following is a rare example where this
     |      distinction is important:
     |
     |      >>> a = np.array([None, None], dtype=object)
     |      >>> a[0] = np.array(3)
     |      >>> a
     |      array([array(3), None], dtype=object)
     |      >>> a.fill(np.array(3))
     |      >>> a
     |      array([array(3), array(3)], dtype=object)
     |
     |      Where other forms of assignments will unpack the array being assigned:
     |
     |      >>> a[...] = np.array(3)
     |      >>> a
     |      array([3, 3], dtype=object)
     |
     |  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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> np.random.seed(123)
     |      >>> x = np.random.randint(9, size=(3, 3))
     |      >>> x
     |      array([[2, 2, 6],
     |             [1, 3, 6],
     |             [1, 0, 1]])
     |      >>> x.item(3)
     |      1
     |      >>> x.item(7)
     |      0
     |      >>> x.item((0, 1))
     |      2
     |      >>> x.item((2, 2))
     |      1
     |
     |      For an array with object dtype, elements are returned as-is.
     |
     |      >>> a = np.array([np.int64(1)], dtype=object)
     |      >>> a.item() #return np.int64
     |      np.int64(1)
     |
     |  max(...)
     |      a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
     |
     |      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, *, where=True)
     |
     |      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, initial=<no value>, where=True)
     |
     |      Return the minimum along a given axis.
     |
     |      Refer to `numpy.amin` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.amin : equivalent function
     |
     |  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)
     |
     |      Partially sorts the elements in the array in such a way that the value of
     |      the element in k-th position is in the position it would be in a sorted
     |      array. In the output array, all elements smaller than the k-th element
     |      are located to the left of this element and all equal or greater are
     |      located to its right. The ordering of the elements in the two partitions
     |      on the either side of the k-th element in the output array 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 of 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.
     |
     |          .. deprecated:: 1.22.0
     |              Passing booleans as index is deprecated.
     |      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 to 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 partitioned copy of an array.
     |      argpartition : Indirect partition.
     |      sort : Full sort.
     |
     |      Notes
     |      -----
     |      See ``np.partition`` for notes on the different algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([3, 4, 2, 1])
     |      >>> a.partition(3)
     |      >>> a
     |      array([2, 1, 3, 4]) # may vary
     |
     |      >>> a.partition((1, 3))
     |      >>> a
     |      array([1, 2, 3, 4])
     |
     |  prod(...)
     |      a.prod(axis=None, dtype=None, out=None, keepdims=False,
     |          initial=1, where=True)
     |
     |      Return the product of the array elements over the given axis
     |
     |      Refer to `numpy.prod` for full documentation.
     |
     |      See Also
     |      --------
     |      numpy.prod : 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', copy=None)
     |
     |      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:
     |
     |      >>> import numpy as np
     |
     |      >>> 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 references or is 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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]], dtype=int32)
     |      >>> x
     |      array([[1.0e+000, 1.5e-323, 1.5e-323],
     |             [1.5e-323, 1.0e+000, 1.5e-323],
     |             [1.5e-323, 1.5e-323, 1.0e+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,
     |      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 flag 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 three of which can be changed by the user:
     |      WRITEBACKIFCOPY, 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);
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> y = np.array([[3, 1, 7],
     |      ...               [2, 0, 0],
     |      ...               [8, 5, 9]])
     |      >>> 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
     |      >>> y.setflags(write=0, align=0)
     |      >>> y.flags
     |        C_CONTIGUOUS : True
     |        F_CONTIGUOUS : False
     |        OWNDATA : True
     |        WRITEABLE : False
     |        ALIGNED : False
     |        WRITEBACKIFCOPY : 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=None, order=None)
     |
     |      Sort an array in-place. Refer to `numpy.sort` for full documentation.
     |
     |      Parameters
     |      ----------
     |      axis : int, optional
     |          Axis along which to sort. Default is -1, which means sort along the
     |          last axis.
     |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
     |          Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
     |          and 'mergesort' use timsort under the covers and, in general, the
     |          actual implementation will vary with datatype. The 'mergesort' option
     |          is retained for backwards compatibility.
     |
     |          .. versionchanged:: 1.15.0
     |             The 'stable' option was added.
     |
     |      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.
     |      numpy.argsort : Indirect sort.
     |      numpy.lexsort : Indirect stable sort on multiple keys.
     |      numpy.searchsorted : Find elements in sorted array.
     |      numpy.partition: Partial sort.
     |
     |      Notes
     |      -----
     |      See `numpy.sort` for notes on the different sorting algorithms.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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([(b'c', 1), (b'a', 2)],
     |            dtype=[('x', 'S1'), ('y', '<i8')])
     |
     |  squeeze(...)
     |      a.squeeze(axis=None)
     |
     |      Remove axes of length one from `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, *, where=True)
     |
     |      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, initial=0, where=True)
     |
     |      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
     |
     |  to_device(...)
     |
     |  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 is produced in C-order by default.
     |      This behavior is controlled by the ``order`` parameter.
     |
     |      .. versionadded:: 1.9.0
     |
     |      Parameters
     |      ----------
     |      order : {'C', 'F', 'A'}, optional
     |          Controls the memory layout of the bytes object. 'C' means C-order,
     |          'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
     |          Fortran contiguous, 'C' otherwise. Default is 'C'.
     |
     |      Returns
     |      -------
     |      s : bytes
     |          Python bytes exhibiting a copy of `a`'s raw data.
     |
     |      See also
     |      --------
     |      frombuffer
     |          Inverse of this operation, construct a 1-dimensional array from Python
     |          bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
     |      >>> x.tobytes()
     |      b'\x00\x00\x01\x00\x02\x00\x03\x00'
     |      >>> x.tobytes('C') == x.tobytes()
     |      True
     |      >>> x.tobytes('F')
     |      b'\x00\x00\x02\x00\x01\x00\x03\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 or Path
     |          An open file object, or a string containing a filename.
     |
     |          .. versionchanged:: 1.17.0
     |              `pathlib.Path` objects are now accepted.
     |
     |      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.
     |
     |      When fid is a file object, array contents are directly written to the
     |      file, bypassing the file object's ``write`` method. As a result, tofile
     |      cannot be used with files objects supporting compression (e.g., GzipFile)
     |      or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
     |
     |  tolist(...)
     |      a.tolist()
     |
     |      Return the array as an ``a.ndim``-levels deep nested list of Python scalars.
     |
     |      Return a copy of the array data as a (nested) Python list.
     |      Data items are converted to the nearest compatible builtin Python type, via
     |      the `~numpy.ndarray.item` function.
     |
     |      If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will
     |      not be a list at all, but a simple Python scalar.
     |
     |      Parameters
     |      ----------
     |      none
     |
     |      Returns
     |      -------
     |      y : object, or list of object, or list of list of object, or ...
     |          The possibly nested list of array elements.
     |
     |      Notes
     |      -----
     |      The array may be recreated via ``a = np.array(a.tolist())``, although this
     |      may sometimes lose precision.
     |
     |      Examples
     |      --------
     |      For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,
     |      except that ``tolist`` changes numpy scalars to Python scalars:
     |
     |      >>> import numpy as np
     |      >>> a = np.uint32([1, 2])
     |      >>> a_list = list(a)
     |      >>> a_list
     |      [1, 2]
     |      >>> type(a_list[0])
     |      <class 'numpy.uint32'>
     |      >>> a_tolist = a.tolist()
     |      >>> a_tolist
     |      [1, 2]
     |      >>> type(a_tolist[0])
     |      <class 'int'>
     |
     |      Additionally, for a 2D array, ``tolist`` applies recursively:
     |
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> list(a)
     |      [array([1, 2]), array([3, 4])]
     |      >>> a.tolist()
     |      [[1, 2], [3, 4]]
     |
     |      The base case for this recursion is a 0D array:
     |
     |      >>> a = np.array(1)
     |      >>> list(a)
     |      Traceback (most recent call last):
     |        ...
     |      TypeError: iteration over a 0-d array
     |      >>> a.tolist()
     |      1
     |
     |  tostring(...)
     |      a.tostring(order='C')
     |
     |      A compatibility alias for `~ndarray.tobytes`, with exactly the same
     |      behavior.
     |
     |      Despite its name, it returns :class:`bytes` not :class:`str`\ s.
     |
     |      .. deprecated:: 1.19.0
     |
     |  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.
     |
     |      Refer to `numpy.transpose` for full documentation.
     |
     |      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 that the
     |         array's `i`-th axis becomes the transposed array'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
     |      -------
     |      p : ndarray
     |          View of the array with its axes suitably permuted.
     |
     |      See Also
     |      --------
     |      transpose : Equivalent function.
     |      ndarray.T : Array property returning the array transposed.
     |      ndarray.reshape : Give a new shape to an array without changing its data.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.transpose()
     |      array([1, 2, 3, 4])
     |
     |  var(...)
     |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
     |
     |      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][, type])
     |
     |      New view of array with the same data.
     |
     |      .. note::
     |          Passing None for ``dtype`` is different from omitting the parameter,
     |          since the former invokes ``dtype(None)`` which is an alias for
     |          ``dtype('float64')``.
     |
     |      Parameters
     |      ----------
     |      dtype : data-type or ndarray sub-class, optional
     |          Data-type descriptor of the returned view, e.g., float32 or int16.
     |          Omitting it 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, omission
     |          of the parameter 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 last axis of ``a`` must be
     |      contiguous. This axis will be resized in the result.
     |
     |      .. versionchanged:: 1.23.0
     |         Only the last axis needs to be contiguous. Previously, the entire array
     |         had to be C-contiguous.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
     |
     |      Viewing array data using a different type and dtype:
     |
     |      >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
     |      >>> y = x.view(dtype=nonneg, type=np.recarray)
     |      >>> x["a"]
     |      array([-1], dtype=int8)
     |      >>> y.a
     |      array([255], dtype=uint8)
     |
     |      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
     |      >>> x
     |      array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      Using a view to convert an array to a recarray:
     |
     |      >>> z = x.view(np.recarray)
     |      >>> z.a
     |      array([1, 3], dtype=int8)
     |
     |      Views share data:
     |
     |      >>> x[0] = (9, 10)
     |      >>> z[0]
     |      np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])
     |
     |      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[:, ::2]
     |      >>> y
     |      array([[1, 3],
     |             [4, 6]], dtype=int16)
     |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      Traceback (most recent call last):
     |          ...
     |      ValueError: To change to a dtype of a different size, the last axis must be contiguous
     |      >>> z = y.copy()
     |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
     |      array([[(1, 3)],
     |             [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
     |
     |      However, views that change dtype are totally fine for arrays with a
     |      contiguous last axis, even if the rest of the axes are not C-contiguous:
     |
     |      >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
     |      >>> x.transpose(1, 0, 2).view(np.int16)
     |      array([[[ 256,  770],
     |              [3340, 3854]],
     |      <BLANKLINE>
     |             [[1284, 1798],
     |              [4368, 4882]],
     |      <BLANKLINE>
     |             [[2312, 2826],
     |              [5396, 5910]]], dtype=int16)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from numpy.ndarray:
     |
     |  __class_getitem__(...)
     |      a.__class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.ndarray` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.ndarray` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.ndarray[Any, np.dtype[Any]]
     |      numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |      numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
     |                          w.r.t. its `dtype.type <numpy.dtype.type>`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from numpy.ndarray:
     |
     |  T
     |      View of the transposed array.
     |
     |      Same as ``self.transpose()``.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.T
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> a
     |      array([1, 2, 3, 4])
     |      >>> a.T
     |      array([1, 2, 3, 4])
     |
     |      See Also
     |      --------
     |      transpose
     |
     |  __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:
     |
     |      >>> import numpy as np
     |      >>> 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):
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.data
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.shape
     |          :noindex:
     |
     |      .. autoattribute:: numpy._core._internal._ctypes.strides
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.data_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.shape_as
     |          :noindex:
     |
     |      .. automethod:: numpy._core._internal._ctypes.strides_as
     |          :noindex:
     |
     |      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 numpy as np
     |      >>> import ctypes
     |      >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
     |      >>> x
     |      array([[0, 1],
     |             [2, 3]], dtype=int32)
     |      >>> x.ctypes.data
     |      31962608 # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
     |      <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
     |      c_uint(0)
     |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
     |      c_ulong(4294967296)
     |      >>> x.ctypes.shape
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
     |      >>> x.ctypes.strides
     |      <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
     |
     |  data
     |      Python buffer object pointing to the start of the array's data.
     |
     |  device
     |
     |  dtype
     |      Data-type of the array's elements.
     |
     |      .. warning::
     |
     |          Setting ``arr.dtype`` is discouraged and may be deprecated in the
     |          future.  Setting will replace the ``dtype`` without modifying the
     |          memory (see also `ndarray.view` and `ndarray.astype`).
     |
     |      Parameters
     |      ----------
     |      None
     |
     |      Returns
     |      -------
     |      d : numpy dtype object
     |
     |      See Also
     |      --------
     |      ndarray.astype : Cast the values contained in the array to a new data-type.
     |      ndarray.view : Create a view of the same data but a different data-type.
     |      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.
     |      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, 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:
     |
     |      - 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
     |      --------
     |      >>> import numpy as np
     |      >>> 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)
     |      <class '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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.sqrt([1+0j, 0+1j])
     |      >>> x.imag
     |      array([ 0.        ,  0.70710678])
     |      >>> x.imag.dtype
     |      dtype('float64')
     |
     |  itemset
     |
     |  itemsize
     |      Length of one array element in bytes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1,2,3], dtype=np.float64)
     |      >>> x.itemsize
     |      8
     |      >>> x = np.array([1,2,3], dtype=np.complex128)
     |      >>> x.itemsize
     |      16
     |
     |  mT
     |      View of the matrix transposed array.
     |
     |      The matrix transpose is the transpose of the last two dimensions, even
     |      if the array is of higher dimension.
     |
     |      .. versionadded:: 2.0
     |
     |      Raises
     |      ------
     |      ValueError
     |          If the array is of dimension less than 2.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> a = np.array([[1, 2], [3, 4]])
     |      >>> a
     |      array([[1, 2],
     |             [3, 4]])
     |      >>> a.mT
     |      array([[1, 3],
     |             [2, 4]])
     |
     |      >>> a = np.arange(8).reshape((2, 2, 2))
     |      >>> a
     |      array([[[0, 1],
     |              [2, 3]],
     |      <BLANKLINE>
     |             [[4, 5],
     |              [6, 7]]])
     |      >>> a.mT
     |      array([[[0, 2],
     |              [1, 3]],
     |      <BLANKLINE>
     |             [[4, 6],
     |              [5, 7]]])
     |
     |  nbytes
     |      Total bytes consumed by the elements of the array.
     |
     |      Notes
     |      -----
     |      Does not include memory consumed by non-element attributes of the
     |      array object.
     |
     |      See Also
     |      --------
     |      sys.getsizeof
     |          Memory consumed by the object itself without parents in case view.
     |          This does include memory consumed by non-element attributes.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      --------
     |      >>> import numpy as np
     |      >>> x = np.array([1, 2, 3])
     |      >>> x.ndim
     |      1
     |      >>> y = np.zeros((2, 3, 4))
     |      >>> y.ndim
     |      3
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the array.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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.
     |
     |      .. warning::
     |
     |          Setting ``arr.shape`` is discouraged and may be deprecated in the
     |          future.  Using `ndarray.reshape` is the preferred approach.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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 in-place modification. Use
     |      `.reshape()` to make a copy with the desired shape.
     |
     |      See Also
     |      --------
     |      numpy.shape : Equivalent getter function.
     |      numpy.reshape : Function similar to setting ``shape``.
     |      ndarray.reshape : Method similar to setting ``shape``.
     |
     |  size
     |      Number of elements in the array.
     |
     |      Equal to ``np.prod(a.shape)``, i.e., the product of the array's
     |      dimensions.
     |
     |      Notes
     |      -----
     |      `a.size` returns a standard arbitrary precision Python integer. This
     |      may not be the case with other methods of obtaining the same value
     |      (like the suggested ``np.prod(a.shape)``, which returns an instance
     |      of ``np.int_``), and may be relevant if the value is used further in
     |      calculations that may overflow a fixed size integer type.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> 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
     |      :ref:`arrays.ndarray`.
     |
     |      .. warning::
     |
     |          Setting ``arr.strides`` is discouraged and may be deprecated in the
     |          future.  `numpy.lib.stride_tricks.as_strided` should be preferred
     |          to create a new view of the same data in a safer way.
     |
     |      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
     |      --------
     |      >>> import numpy as np
     |      >>> 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 record(void)
     |  A data-type scalar that allows field access as attribute lookup.
     |
     |  Method resolution order:
     |      record
     |      void
     |      flexible
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getattribute__(self, attr) from numpy._core.records.record
     |      Return getattr(self, name).
     |
     |  __getitem__(self, indx) from numpy._core.records.record
     |      Return self[key].
     |
     |  __repr__(self) from numpy._core.records.record
     |      Return repr(self).
     |
     |  __setattr__(self, attr, val) from numpy._core.records.record
     |      Implement setattr(self, name, value).
     |
     |  __str__(self) from numpy._core.records.record
     |      Return str(self).
     |
     |  pprint(self) from numpy._core.records.record
     |      Pretty-print all fields.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from void:
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from void:
     |
     |  __new__(*args, **kwargs) class method of void
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from void:
     |
     |  base
     |      base object
     |
     |  dtype
     |      dtype object
     |
     |  flags
     |      integer value of flags
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    short = class int16(signedinteger)
     |  Signed integer type, compatible with C ``short``.
     |
     |  :Character code: ``'h'``
     |  :Canonical name: `numpy.short`
     |  :Alias on this platform (win32 AMD64): `numpy.int16`: 16-bit signed integer (``-32_768`` to ``32_767``).
     |
     |  Method resolution order:
     |      int16
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      int16.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.int16(127).bit_count()
     |      7
     |      >>> np.int16(-127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class signedinteger(integer)
     |  Abstract base class of all signed integer scalar types.
     |
     |  Method resolution order:
     |      signedinteger
     |      integer
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from number:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    single = class float32(floating)
     |  Single-precision floating-point number type, compatible with C ``float``.
     |
     |  :Character code: ``'f'``
     |  :Canonical name: `numpy.single`
     |  :Alias on this platform (win32 AMD64): `numpy.float32`: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.
     |
     |  Method resolution order:
     |      float32
     |      floating
     |      inexact
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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)
     |
     |  __le__(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
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  as_integer_ratio(...)
     |      single.as_integer_ratio() -> (int, int)
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original
     |      floating point number, and with a positive denominator.
     |      Raise `OverflowError` on infinities and a `ValueError` on NaNs.
     |
     |      >>> np.single(10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> np.single(0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> np.single(-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  is_integer(...)
     |      single.is_integer() -> bool
     |
     |      Return ``True`` if the floating point number is finite with integral
     |      value, and ``False`` otherwise.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> np.single(-2.0).is_integer()
     |      True
     |      >>> np.single(3.2).is_integer()
     |      False
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from floating:
     |
     |  __round__(...)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class str_(builtins.str, character)
     |  A unicode string.
     |
     |  This type strips trailing null codepoints.
     |
     |  >>> s = np.str_("abc\x00")
     |  >>> s
     |  'abc'
     |
     |  Unlike the builtin :class:`str`, this supports the
     |  :ref:`python:bufferobjects`, exposing its contents as UCS4:
     |
     |  >>> m = memoryview(np.str_("abc"))
     |  >>> m.format
     |  '3w'
     |  >>> m.tobytes()
     |  b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'
     |
     |  :Character code: ``'U'``
     |
     |  Method resolution order:
     |      str_
     |      builtins.str
     |      character
     |      flexible
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.str:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(key in self).
     |
     |  __format__(self, format_spec, /)
     |      Return a formatted version of the string as described by format_spec.
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __getnewargs__(...)
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __sizeof__(self, /)
     |      Return the size of the string in memory, in bytes.
     |
     |  capitalize(self, /)
     |      Return a capitalized version of the string.
     |
     |      More specifically, make the first character have upper case and the rest lower
     |      case.
     |
     |  casefold(self, /)
     |      Return a version of the string suitable for caseless comparisons.
     |
     |  center(self, width, fillchar=' ', /)
     |      Return a centered 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(self, /, encoding='utf-8', errors='strict')
     |      Encode the string using the codec registered for encoding.
     |
     |      encoding
     |        The encoding in which to encode the string.
     |      errors
     |        The error handling scheme to use for encoding errors.
     |        The 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(self, /, tabsize=8)
     |      Return a copy 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(self, /)
     |      Return True if the string is an alpha-numeric string, False otherwise.
     |
     |      A string is alpha-numeric if all characters in the string are alpha-numeric and
     |      there is at least one character in the string.
     |
     |  isalpha(self, /)
     |      Return True if the string is an alphabetic string, False otherwise.
     |
     |      A string is alphabetic if all characters in the string are alphabetic and there
     |      is at least one character in the string.
     |
     |  isascii(self, /)
     |      Return True if all characters in the string are ASCII, False otherwise.
     |
     |      ASCII characters have code points in the range U+0000-U+007F.
     |      Empty string is ASCII too.
     |
     |  isdecimal(self, /)
     |      Return True if the string is a decimal string, False otherwise.
     |
     |      A string is a decimal string if all characters in the string are decimal and
     |      there is at least one character in the string.
     |
     |  isdigit(self, /)
     |      Return True if the string is a digit string, False otherwise.
     |
     |      A string is a digit string if all characters in the string are digits and there
     |      is at least one character in the string.
     |
     |  isidentifier(self, /)
     |      Return True if the string is a valid Python identifier, False otherwise.
     |
     |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
     |      such as "def" or "class".
     |
     |  islower(self, /)
     |      Return True if the string is a lowercase string, False otherwise.
     |
     |      A string is lowercase if all cased characters in the string are lowercase and
     |      there is at least one cased character in the string.
     |
     |  isnumeric(self, /)
     |      Return True if the string is a numeric string, False otherwise.
     |
     |      A string is numeric if all characters in the string are numeric and there is at
     |      least one character in the string.
     |
     |  isprintable(self, /)
     |      Return True if the string is printable, False otherwise.
     |
     |      A string is printable if all of its characters are considered printable in
     |      repr() or if it is empty.
     |
     |  isspace(self, /)
     |      Return True if the string is a whitespace string, False otherwise.
     |
     |      A string is whitespace if all characters in the string are whitespace and there
     |      is at least one character in the string.
     |
     |  istitle(self, /)
     |      Return True if the string is a title-cased string, False otherwise.
     |
     |      In a title-cased string, upper- and title-case characters may only
     |      follow uncased characters and lowercase characters only cased ones.
     |
     |  isupper(self, /)
     |      Return True if the string is an uppercase string, False otherwise.
     |
     |      A string is uppercase if all cased characters in the string are uppercase and
     |      there is at least one cased character in the string.
     |
     |  join(self, iterable, /)
     |      Concatenate any number of strings.
     |
     |      The string whose method is called is inserted in between each given string.
     |      The result is returned as a new string.
     |
     |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
     |
     |  ljust(self, width, fillchar=' ', /)
     |      Return a left-justified string of length width.
     |
     |      Padding is done using the specified fill character (default is a space).
     |
     |  lower(self, /)
     |      Return a copy of the string converted to lowercase.
     |
     |  lstrip(self, chars=None, /)
     |      Return a copy of the string with leading whitespace removed.
     |
     |      If chars is given and not None, remove characters in chars instead.
     |
     |  partition(self, sep, /)
     |      Partition the string into three parts using the given separator.
     |
     |      This will search for the separator in the string.  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 string
     |      and two empty strings.
     |
     |  removeprefix(self, prefix, /)
     |      Return a str with the given prefix string removed if present.
     |
     |      If the string starts with the prefix string, return string[len(prefix):].
     |      Otherwise, return a copy of the original string.
     |
     |  removesuffix(self, suffix, /)
     |      Return a str with the given suffix string removed if present.
     |
     |      If the string ends with the suffix string and that suffix is not empty,
     |      return string[:-len(suffix)]. Otherwise, return a copy of the original
     |      string.
     |
     |  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(...)
     |      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(self, width, fillchar=' ', /)
     |      Return a right-justified string of length width.
     |
     |      Padding is done using the specified fill character (default is a space).
     |
     |  rpartition(self, sep, /)
     |      Partition the string into three parts using the given separator.
     |
     |      This will search for the separator in the string, 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 strings
     |      and the original string.
     |
     |  rsplit(self, /, sep=None, maxsplit=-1)
     |      Return a list of the substrings in the string, using sep as the separator string.
     |
     |        sep
     |          The separator used to split the string.
     |
     |          When set to None (the default value), will split on any whitespace
     |          character (including \n \r \t \f and spaces) and will discard
     |          empty strings from the result.
     |        maxsplit
     |          Maximum number of splits.
     |          -1 (the default value) means no limit.
     |
     |      Splitting starts at the end of the string and works to the front.
     |
     |  rstrip(self, chars=None, /)
     |      Return a copy of the string with trailing whitespace removed.
     |
     |      If chars is given and not None, remove characters in chars instead.
     |
     |  split(self, /, sep=None, maxsplit=-1)
     |      Return a list of the substrings in the string, using sep as the separator string.
     |
     |        sep
     |          The separator used to split the string.
     |
     |          When set to None (the default value), will split on any whitespace
     |          character (including \n \r \t \f and spaces) and will discard
     |          empty strings from the result.
     |        maxsplit
     |          Maximum number of splits.
     |          -1 (the default value) means no limit.
     |
     |      Splitting starts at the front of the string and works to the end.
     |
     |      Note, str.split() is mainly useful for data that has been intentionally
     |      delimited.  With natural text that includes punctuation, consider using
     |      the regular expression module.
     |
     |  splitlines(self, /, keepends=False)
     |      Return a list of the lines in the string, 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(self, chars=None, /)
     |      Return a copy of the string with leading and trailing whitespace removed.
     |
     |      If chars is given and not None, remove characters in chars instead.
     |
     |  swapcase(self, /)
     |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
     |
     |  title(self, /)
     |      Return a version of the string where each word is titlecased.
     |
     |      More specifically, words start with uppercased characters and all remaining
     |      cased characters have lower case.
     |
     |  translate(self, table, /)
     |      Replace each character in the string using the given translation table.
     |
     |        table
     |          Translation table, which must be a mapping of Unicode ordinals to
     |          Unicode ordinals, strings, or None.
     |
     |      The table must implement lookup/indexing via __getitem__, for instance a
     |      dictionary or list.  If this operation raises LookupError, the character is
     |      left untouched.  Characters mapped to None are deleted.
     |
     |  upper(self, /)
     |      Return a copy of the string converted to uppercase.
     |
     |  zfill(self, width, /)
     |      Pad a numeric string with zeros on the left, to fill a field of the given width.
     |
     |      The string is never truncated.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.str:
     |
     |  maketrans(...)
     |      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.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(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.
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class timedelta64(signedinteger)
     |  A timedelta stored as a 64-bit integer.
     |
     |  See :ref:`arrays.datetime` for more information.
     |
     |  :Character code: ``'m'``
     |
     |  Method resolution order:
     |      timedelta64
     |      signedinteger
     |      integer
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    ubyte = class uint8(unsignedinteger)
     |  Unsigned integer type, compatible with C ``unsigned char``.
     |
     |  :Character code: ``'B'``
     |  :Canonical name: `numpy.ubyte`
     |  :Alias on this platform (win32 AMD64): `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``).
     |
     |  Method resolution order:
     |      uint8
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint8.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint8(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class ufunc(builtins.object)
     |  Functions that operate element by element on whole arrays.
     |
     |  To see the documentation for a specific ufunc, use `info`.  For
     |  example, ``np.info(np.sin)``.  Because ufuncs are written in C
     |  (for speed) and linked into Python with NumPy's ufunc facility,
     |  Python's help() function finds this page whenever help() is called
     |  on a ufunc.
     |
     |  A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`.
     |
     |  **Calling ufuncs:** ``op(*x[, out], where=True, **kwargs)``
     |
     |  Apply `op` to the arguments `*x` elementwise, broadcasting the arguments.
     |
     |  The broadcasting rules are:
     |
     |  * Dimensions of length 1 may be prepended to either array.
     |  * Arrays may be repeated along dimensions of length 1.
     |
     |  Parameters
     |  ----------
     |  *x : array_like
     |      Input arrays.
     |  out : ndarray, None, or tuple of ndarray and None, optional
     |      Alternate array object(s) in which to put the result; if provided, it
     |      must have a shape that the inputs broadcast to. A tuple of arrays
     |      (possible only as a keyword argument) must have length equal to the
     |      number of outputs; use None for uninitialized outputs to be
     |      allocated by the ufunc.
     |  where : array_like, optional
     |      This condition is broadcast over the input. At locations where the
     |      condition is True, the `out` array will be set to the ufunc result.
     |      Elsewhere, the `out` array will retain its original value.
     |      Note that if an uninitialized `out` array is created via the default
     |      ``out=None``, locations within it where the condition is False will
     |      remain uninitialized.
     |  **kwargs
     |      For other keyword-only arguments, see the :ref:`ufunc docs <ufuncs.kwargs>`.
     |
     |  Returns
     |  -------
     |  r : ndarray or tuple of ndarray
     |      `r` will have the shape that the arrays in `x` broadcast to; if `out` is
     |      provided, it will be returned. If not, `r` will be allocated and
     |      may contain uninitialized values. If the function has more than one
     |      output, then the result will be a tuple of arrays.
     |
     |  Methods defined here:
     |
     |  __call__(self, /, *args, **kwargs)
     |      Call self as a function.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  accumulate(...)
     |      accumulate(array, axis=0, dtype=None, out=None)
     |
     |      Accumulate the result of applying the operator to all elements.
     |
     |      For a one-dimensional array, accumulate produces results equivalent to::
     |
     |        r = np.empty(len(A))
     |        t = op.identity        # op = the ufunc being applied to A's  elements
     |        for i in range(len(A)):
     |            t = op(t, A[i])
     |            r[i] = t
     |        return r
     |
     |      For example, add.accumulate() is equivalent to np.cumsum().
     |
     |      For a multi-dimensional array, accumulate is applied along only one
     |      axis (axis zero by default; see Examples below) so repeated use is
     |      necessary if one wants to accumulate over multiple axes.
     |
     |      Parameters
     |      ----------
     |      array : array_like
     |          The array to act on.
     |      axis : int, optional
     |          The axis along which to apply the accumulation; default is zero.
     |      dtype : data-type code, optional
     |          The data-type used to represent the intermediate results. Defaults
     |          to the data-type of the output array if such is provided, or the
     |          data-type of the input array if no output array is provided.
     |      out : ndarray, None, or tuple of ndarray and None, optional
     |          A location into which the result is stored. If not provided or None,
     |          a freshly-allocated array is returned. For consistency with
     |          ``ufunc.__call__``, if given as a keyword, this may be wrapped in a
     |          1-element tuple.
     |
     |          .. versionchanged:: 1.13.0
     |             Tuples are allowed for keyword argument.
     |
     |      Returns
     |      -------
     |      r : ndarray
     |          The accumulated values. If `out` was supplied, `r` is a reference to
     |          `out`.
     |
     |      Examples
     |      --------
     |      1-D array examples:
     |
     |      >>> import numpy as np
     |      >>> np.add.accumulate([2, 3, 5])
     |      array([ 2,  5, 10])
     |      >>> np.multiply.accumulate([2, 3, 5])
     |      array([ 2,  6, 30])
     |
     |      2-D array examples:
     |
     |      >>> I = np.eye(2)
     |      >>> I
     |      array([[1.,  0.],
     |             [0.,  1.]])
     |
     |      Accumulate along axis 0 (rows), down columns:
     |
     |      >>> np.add.accumulate(I, 0)
     |      array([[1.,  0.],
     |             [1.,  1.]])
     |      >>> np.add.accumulate(I) # no axis specified = axis zero
     |      array([[1.,  0.],
     |             [1.,  1.]])
     |
     |      Accumulate along axis 1 (columns), through rows:
     |
     |      >>> np.add.accumulate(I, 1)
     |      array([[1.,  1.],
     |             [0.,  1.]])
     |
     |  at(...)
     |      at(a, indices, b=None, /)
     |
     |      Performs unbuffered in place operation on operand 'a' for elements
     |      specified by 'indices'. For addition ufunc, this method is equivalent to
     |      ``a[indices] += b``, except that results are accumulated for elements that
     |      are indexed more than once. For example, ``a[[0,0]] += 1`` will only
     |      increment the first element once because of buffering, whereas
     |      ``add.at(a, [0,0], 1)`` will increment the first element twice.
     |
     |      .. versionadded:: 1.8.0
     |
     |      Parameters
     |      ----------
     |      a : array_like
     |          The array to perform in place operation on.
     |      indices : array_like or tuple
     |          Array like index object or slice object for indexing into first
     |          operand. If first operand has multiple dimensions, indices can be a
     |          tuple of array like index objects or slice objects.
     |      b : array_like
     |          Second operand for ufuncs requiring two operands. Operand must be
     |          broadcastable over first operand after indexing or slicing.
     |
     |      Examples
     |      --------
     |      Set items 0 and 1 to their negative values:
     |
     |      >>> import numpy as np
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> np.negative.at(a, [0, 1])
     |      >>> a
     |      array([-1, -2,  3,  4])
     |
     |      Increment items 0 and 1, and increment item 2 twice:
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> np.add.at(a, [0, 1, 2, 2], 1)
     |      >>> a
     |      array([2, 3, 5, 4])
     |
     |      Add items 0 and 1 in first array to second array,
     |      and store results in first array:
     |
     |      >>> a = np.array([1, 2, 3, 4])
     |      >>> b = np.array([1, 2])
     |      >>> np.add.at(a, [0, 1], b)
     |      >>> a
     |      array([2, 4, 3, 4])
     |
     |  outer(...)
     |      outer(A, B, /, **kwargs)
     |
     |      Apply the ufunc `op` to all pairs (a, b) with a in `A` and b in `B`.
     |
     |      Let ``M = A.ndim``, ``N = B.ndim``. Then the result, `C`, of
     |      ``op.outer(A, B)`` is an array of dimension M + N such that:
     |
     |      .. math:: C[i_0, ..., i_{M-1}, j_0, ..., j_{N-1}] =
     |         op(A[i_0, ..., i_{M-1}], B[j_0, ..., j_{N-1}])
     |
     |      For `A` and `B` one-dimensional, this is equivalent to::
     |
     |        r = empty(len(A),len(B))
     |        for i in range(len(A)):
     |            for j in range(len(B)):
     |                r[i,j] = op(A[i], B[j])  # op = ufunc in question
     |
     |      Parameters
     |      ----------
     |      A : array_like
     |          First array
     |      B : array_like
     |          Second array
     |      kwargs : any
     |          Arguments to pass on to the ufunc. Typically `dtype` or `out`.
     |          See `ufunc` for a comprehensive overview of all available arguments.
     |
     |      Returns
     |      -------
     |      r : ndarray
     |          Output array
     |
     |      See Also
     |      --------
     |      numpy.outer : A less powerful version of ``np.multiply.outer``
     |                    that `ravel`\ s all inputs to 1D. This exists
     |                    primarily for compatibility with old code.
     |
     |      tensordot : ``np.tensordot(a, b, axes=((), ()))`` and
     |                  ``np.multiply.outer(a, b)`` behave same for all
     |                  dimensions of a and b.
     |
     |      Examples
     |      --------
     |      >>> np.multiply.outer([1, 2, 3], [4, 5, 6])
     |      array([[ 4,  5,  6],
     |             [ 8, 10, 12],
     |             [12, 15, 18]])
     |
     |      A multi-dimensional example:
     |
     |      >>> A = np.array([[1, 2, 3], [4, 5, 6]])
     |      >>> A.shape
     |      (2, 3)
     |      >>> B = np.array([[1, 2, 3, 4]])
     |      >>> B.shape
     |      (1, 4)
     |      >>> C = np.multiply.outer(A, B)
     |      >>> C.shape; C
     |      (2, 3, 1, 4)
     |      array([[[[ 1,  2,  3,  4]],
     |              [[ 2,  4,  6,  8]],
     |              [[ 3,  6,  9, 12]]],
     |             [[[ 4,  8, 12, 16]],
     |              [[ 5, 10, 15, 20]],
     |              [[ 6, 12, 18, 24]]]])
     |
     |  reduce(...)
     |      reduce(array, axis=0, dtype=None, out=None, keepdims=False, initial=<no value>, where=True)
     |
     |      Reduces `array`'s dimension by one, by applying ufunc along one axis.
     |
     |      Let :math:`array.shape = (N_0, ..., N_i, ..., N_{M-1})`.  Then
     |      :math:`ufunc.reduce(array, axis=i)[k_0, ..,k_{i-1}, k_{i+1}, .., k_{M-1}]` =
     |      the result of iterating `j` over :math:`range(N_i)`, cumulatively applying
     |      ufunc to each :math:`array[k_0, ..,k_{i-1}, j, k_{i+1}, .., k_{M-1}]`.
     |      For a one-dimensional array, reduce produces results equivalent to:
     |      ::
     |
     |       r = op.identity # op = ufunc
     |       for i in range(len(A)):
     |         r = op(r, A[i])
     |       return r
     |
     |      For example, add.reduce() is equivalent to sum().
     |
     |      Parameters
     |      ----------
     |      array : array_like
     |          The array to act on.
     |      axis : None or int or tuple of ints, optional
     |          Axis or axes along which a reduction is performed.
     |          The default (`axis` = 0) is perform a reduction over the first
     |          dimension 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 None, a reduction is performed over all the axes.
     |          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.
     |
     |          For operations which are either not commutative or not associative,
     |          doing a reduction over multiple axes is not well-defined. The
     |          ufuncs do not currently raise an exception in this case, but will
     |          likely do so in the future.
     |      dtype : data-type code, optional
     |          The data type used to perform the operation. Defaults to that of
     |          ``out`` if given, and the data type of ``array`` otherwise (though
     |          upcast to conserve precision for some cases, such as
     |          ``numpy.add.reduce`` for integer or boolean input).
     |      out : ndarray, None, or tuple of ndarray and None, optional
     |          A location into which the result is stored. If not provided or None,
     |          a freshly-allocated array is returned. For consistency with
     |          ``ufunc.__call__``, if given as a keyword, this may be wrapped in a
     |          1-element tuple.
     |
     |          .. versionchanged:: 1.13.0
     |             Tuples are allowed for keyword argument.
     |      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:: 1.7.0
     |      initial : scalar, optional
     |          The value with which to start the reduction.
     |          If the ufunc has no identity or the dtype is object, this defaults
     |          to None - otherwise it defaults to ufunc.identity.
     |          If ``None`` is given, the first element of the reduction is used,
     |          and an error is thrown if the reduction is empty.
     |
     |          .. versionadded:: 1.15.0
     |
     |      where : array_like of bool, optional
     |          A boolean array which is broadcasted to match the dimensions
     |          of `array`, and selects elements to include in the reduction. Note
     |          that for ufuncs like ``minimum`` that do not have an identity
     |          defined, one has to pass in also ``initial``.
     |
     |          .. versionadded:: 1.17.0
     |
     |      Returns
     |      -------
     |      r : ndarray
     |          The reduced array. If `out` was supplied, `r` is a reference to it.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.multiply.reduce([2,3,5])
     |      30
     |
     |      A multi-dimensional array example:
     |
     |      >>> X = np.arange(8).reshape((2,2,2))
     |      >>> X
     |      array([[[0, 1],
     |              [2, 3]],
     |             [[4, 5],
     |              [6, 7]]])
     |      >>> np.add.reduce(X, 0)
     |      array([[ 4,  6],
     |             [ 8, 10]])
     |      >>> np.add.reduce(X) # confirm: default axis value is 0
     |      array([[ 4,  6],
     |             [ 8, 10]])
     |      >>> np.add.reduce(X, 1)
     |      array([[ 2,  4],
     |             [10, 12]])
     |      >>> np.add.reduce(X, 2)
     |      array([[ 1,  5],
     |             [ 9, 13]])
     |
     |      You can use the ``initial`` keyword argument to initialize the reduction
     |      with a different value, and ``where`` to select specific elements to include:
     |
     |      >>> np.add.reduce([10], initial=5)
     |      15
     |      >>> np.add.reduce(np.ones((2, 2, 2)), axis=(0, 2), initial=10)
     |      array([14., 14.])
     |      >>> a = np.array([10., np.nan, 10])
     |      >>> np.add.reduce(a, where=~np.isnan(a))
     |      20.0
     |
     |      Allows reductions of empty arrays where they would normally fail, i.e.
     |      for ufuncs without an identity.
     |
     |      >>> np.minimum.reduce([], initial=np.inf)
     |      inf
     |      >>> np.minimum.reduce([[1., 2.], [3., 4.]], initial=10., where=[True, False])
     |      array([ 1., 10.])
     |      >>> np.minimum.reduce([])
     |      Traceback (most recent call last):
     |          ...
     |      ValueError: zero-size array to reduction operation minimum which has no identity
     |
     |  reduceat(...)
     |      reduceat(array, indices, axis=0, dtype=None, out=None)
     |
     |      Performs a (local) reduce with specified slices over a single axis.
     |
     |      For i in ``range(len(indices))``, `reduceat` computes
     |      ``ufunc.reduce(array[indices[i]:indices[i+1]])``, which becomes the i-th
     |      generalized "row" parallel to `axis` in the final result (i.e., in a
     |      2-D array, for example, if `axis = 0`, it becomes the i-th row, but if
     |      `axis = 1`, it becomes the i-th column).  There are three exceptions to this:
     |
     |      * when ``i = len(indices) - 1`` (so for the last index),
     |        ``indices[i+1] = array.shape[axis]``.
     |      * if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is
     |        simply ``array[indices[i]]``.
     |      * if ``indices[i] >= len(array)`` or ``indices[i] < 0``, an error is raised.
     |
     |      The shape of the output depends on the size of `indices`, and may be
     |      larger than `array` (this happens if ``len(indices) > array.shape[axis]``).
     |
     |      Parameters
     |      ----------
     |      array : array_like
     |          The array to act on.
     |      indices : array_like
     |          Paired indices, comma separated (not colon), specifying slices to
     |          reduce.
     |      axis : int, optional
     |          The axis along which to apply the reduceat.
     |      dtype : data-type code, optional
     |          The data type used to perform the operation. Defaults to that of
     |          ``out`` if given, and the data type of ``array`` otherwise (though
     |          upcast to conserve precision for some cases, such as
     |          ``numpy.add.reduce`` for integer or boolean input).
     |      out : ndarray, None, or tuple of ndarray and None, optional
     |          A location into which the result is stored. If not provided or None,
     |          a freshly-allocated array is returned. For consistency with
     |          ``ufunc.__call__``, if given as a keyword, this may be wrapped in a
     |          1-element tuple.
     |
     |          .. versionchanged:: 1.13.0
     |             Tuples are allowed for keyword argument.
     |
     |      Returns
     |      -------
     |      r : ndarray
     |          The reduced values. If `out` was supplied, `r` is a reference to
     |          `out`.
     |
     |      Notes
     |      -----
     |      A descriptive example:
     |
     |      If `array` is 1-D, the function `ufunc.accumulate(array)` is the same as
     |      ``ufunc.reduceat(array, indices)[::2]`` where `indices` is
     |      ``range(len(array) - 1)`` with a zero placed
     |      in every other element:
     |      ``indices = zeros(2 * len(array) - 1)``,
     |      ``indices[1::2] = range(1, len(array))``.
     |
     |      Don't be fooled by this attribute's name: `reduceat(array)` is not
     |      necessarily smaller than `array`.
     |
     |      Examples
     |      --------
     |      To take the running sum of four successive values:
     |
     |      >>> import numpy as np
     |      >>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
     |      array([ 6, 10, 14, 18])
     |
     |      A 2-D example:
     |
     |      >>> x = np.linspace(0, 15, 16).reshape(4,4)
     |      >>> x
     |      array([[ 0.,   1.,   2.,   3.],
     |             [ 4.,   5.,   6.,   7.],
     |             [ 8.,   9.,  10.,  11.],
     |             [12.,  13.,  14.,  15.]])
     |
     |      ::
     |
     |       # reduce such that the result has the following five rows:
     |       # [row1 + row2 + row3]
     |       # [row4]
     |       # [row2]
     |       # [row3]
     |       # [row1 + row2 + row3 + row4]
     |
     |      >>> np.add.reduceat(x, [0, 3, 1, 2, 0])
     |      array([[12.,  15.,  18.,  21.],
     |             [12.,  13.,  14.,  15.],
     |             [ 4.,   5.,   6.,   7.],
     |             [ 8.,   9.,  10.,  11.],
     |             [24.,  28.,  32.,  36.]])
     |
     |      ::
     |
     |       # reduce such that result has the following two columns:
     |       # [col1 * col2 * col3, col4]
     |
     |      >>> np.multiply.reduceat(x, [0, 3], 1)
     |      array([[   0.,     3.],
     |             [ 120.,     7.],
     |             [ 720.,    11.],
     |             [2184.,    15.]])
     |
     |  resolve_dtypes(...)
     |      resolve_dtypes(dtypes, *, signature=None, casting=None, reduction=False)
     |
     |      Find the dtypes NumPy will use for the operation.  Both input and
     |      output dtypes are returned and may differ from those provided.
     |
     |      .. note::
     |
     |          This function always applies NEP 50 rules since it is not provided
     |          any actual values.  The Python types ``int``, ``float``, and
     |          ``complex`` thus behave weak and should be passed for "untyped"
     |          Python input.
     |
     |      Parameters
     |      ----------
     |      dtypes : tuple of dtypes, None, or literal int, float, complex
     |          The input dtypes for each operand.  Output operands can be
     |          None, indicating that the dtype must be found.
     |      signature : tuple of DTypes or None, optional
     |          If given, enforces exact DType (classes) of the specific operand.
     |          The ufunc ``dtype`` argument is equivalent to passing a tuple with
     |          only output dtypes set.
     |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
     |          The casting mode when casting is necessary.  This is identical to
     |          the ufunc call casting modes.
     |      reduction : boolean
     |          If given, the resolution assumes a reduce operation is happening
     |          which slightly changes the promotion and type resolution rules.
     |          `dtypes` is usually something like ``(None, np.dtype("i2"), None)``
     |          for reductions (first input is also the output).
     |
     |          .. note::
     |
     |              The default casting mode is "same_kind", however, as of
     |              NumPy 1.24, NumPy uses "unsafe" for reductions.
     |
     |      Returns
     |      -------
     |      dtypes : tuple of dtypes
     |          The dtypes which NumPy would use for the calculation.  Note that
     |          dtypes may not match the passed in ones (casting is necessary).
     |
     |
     |      Examples
     |      --------
     |      This API requires passing dtypes, define them for convenience:
     |
     |      >>> import numpy as np
     |      >>> int32 = np.dtype("int32")
     |      >>> float32 = np.dtype("float32")
     |
     |      The typical ufunc call does not pass an output dtype.  `numpy.add` has two
     |      inputs and one output, so leave the output as ``None`` (not provided):
     |
     |      >>> np.add.resolve_dtypes((int32, float32, None))
     |      (dtype('float64'), dtype('float64'), dtype('float64'))
     |
     |      The loop found uses "float64" for all operands (including the output), the
     |      first input would be cast.
     |
     |      ``resolve_dtypes`` supports "weak" handling for Python scalars by passing
     |      ``int``, ``float``, or ``complex``:
     |
     |      >>> np.add.resolve_dtypes((float32, float, None))
     |      (dtype('float32'), dtype('float32'), dtype('float32'))
     |
     |      Where the Python ``float`` behaves samilar to a Python value ``0.0``
     |      in a ufunc call.  (See :ref:`NEP 50 <NEP50>` for details.)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  identity
     |      The identity value.
     |
     |      Data attribute containing the identity element for the ufunc,
     |      if it has one. If it does not, the attribute value is None.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.add.identity
     |      0
     |      >>> np.multiply.identity
     |      1
     |      >>> np.power.identity
     |      1
     |      >>> print(np.exp.identity)
     |      None
     |
     |  nargs
     |      The number of arguments.
     |
     |      Data attribute containing the number of arguments the ufunc takes, including
     |      optional ones.
     |
     |      Notes
     |      -----
     |      Typically this value will be one more than what you might expect
     |      because all ufuncs take  the optional "out" argument.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.add.nargs
     |      3
     |      >>> np.multiply.nargs
     |      3
     |      >>> np.power.nargs
     |      3
     |      >>> np.exp.nargs
     |      2
     |
     |  nin
     |      The number of inputs.
     |
     |      Data attribute containing the number of arguments the ufunc treats as input.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.add.nin
     |      2
     |      >>> np.multiply.nin
     |      2
     |      >>> np.power.nin
     |      2
     |      >>> np.exp.nin
     |      1
     |
     |  nout
     |      The number of outputs.
     |
     |      Data attribute containing the number of arguments the ufunc treats as output.
     |
     |      Notes
     |      -----
     |      Since all ufuncs can take output arguments, this will always be at least 1.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.add.nout
     |      1
     |      >>> np.multiply.nout
     |      1
     |      >>> np.power.nout
     |      1
     |      >>> np.exp.nout
     |      1
     |
     |  ntypes
     |      The number of types.
     |
     |      The number of numerical NumPy types - of which there are 18 total - on which
     |      the ufunc can operate.
     |
     |      See Also
     |      --------
     |      numpy.ufunc.types
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.add.ntypes
     |      18
     |      >>> np.multiply.ntypes
     |      18
     |      >>> np.power.ntypes
     |      17
     |      >>> np.exp.ntypes
     |      7
     |      >>> np.remainder.ntypes
     |      14
     |
     |  signature
     |      Definition of the core elements a generalized ufunc operates on.
     |
     |      The signature determines how the dimensions of each input/output array
     |      are split into core and loop dimensions:
     |
     |      1. Each dimension in the signature is matched to a dimension of the
     |         corresponding passed-in array, starting from the end of the shape tuple.
     |      2. Core dimensions assigned to the same label in the signature must have
     |         exactly matching sizes, no broadcasting is performed.
     |      3. The core dimensions are removed from all inputs and the remaining
     |         dimensions are broadcast together, defining the loop dimensions.
     |
     |      Notes
     |      -----
     |      Generalized ufuncs are used internally in many linalg functions, and in
     |      the testing suite; the examples below are taken from these.
     |      For ufuncs that operate on scalars, the signature is None, which is
     |      equivalent to '()' for every argument.
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.linalg._umath_linalg.det.signature
     |      '(m,m)->()'
     |      >>> np.matmul.signature
     |      '(n?,k),(k,m?)->(n?,m?)'
     |      >>> np.add.signature is None
     |      True  # equivalent to '(),()->()'
     |
     |  types
     |      Returns a list with types grouped input->output.
     |
     |      Data attribute listing the data-type "Domain-Range" groupings the ufunc can
     |      deliver. The data-types are given using the character codes.
     |
     |      See Also
     |      --------
     |      numpy.ufunc.ntypes
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.add.types
     |      ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
     |      'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
     |      'GG->G', 'OO->O']
     |
     |      >>> np.multiply.types
     |      ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
     |      'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
     |      'GG->G', 'OO->O']
     |
     |      >>> np.power.types
     |      ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
     |      'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G',
     |      'OO->O']
     |
     |      >>> np.exp.types
     |      ['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O']
     |
     |      >>> np.remainder.types
     |      ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
     |      'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O']

    uint = class uint64(unsignedinteger)
     |  Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'Q'``
     |  :Canonical name: `numpy.uint`
     |  :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
     |  :Alias on this platform (win32 AMD64): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``.
     |
     |  Method resolution order:
     |      uint64
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint64(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class uint16(unsignedinteger)
     |  Unsigned integer type, compatible with C ``unsigned short``.
     |
     |  :Character code: ``'H'``
     |  :Canonical name: `numpy.ushort`
     |  :Alias on this platform (win32 AMD64): `numpy.uint16`: 16-bit unsigned integer (``0`` to ``65_535``).
     |
     |  Method resolution order:
     |      uint16
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint16.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint16(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class uint32(unsignedinteger)
     |  Method resolution order:
     |      uint32
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint32.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint32(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class uint64(unsignedinteger)
     |  Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'Q'``
     |  :Canonical name: `numpy.uint`
     |  :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
     |  :Alias on this platform (win32 AMD64): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``.
     |
     |  Method resolution order:
     |      uint64
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint64(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class uint8(unsignedinteger)
     |  Unsigned integer type, compatible with C ``unsigned char``.
     |
     |  :Character code: ``'B'``
     |  :Canonical name: `numpy.ubyte`
     |  :Alias on this platform (win32 AMD64): `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``).
     |
     |  Method resolution order:
     |      uint8
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint8.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint8(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class uintc(unsignedinteger)
     |  Unsigned integer type, compatible with C ``unsigned int``.
     |
     |  :Character code: ``'I'``
     |
     |  Method resolution order:
     |      uintc
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    uintp = class uint64(unsignedinteger)
     |  Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'Q'``
     |  :Canonical name: `numpy.uint`
     |  :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
     |  :Alias on this platform (win32 AMD64): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``.
     |
     |  Method resolution order:
     |      uint64
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint64(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    ulong = class uint32(unsignedinteger)
     |  Method resolution order:
     |      uint32
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint32.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint32(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    ulonglong = class uint64(unsignedinteger)
     |  Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
     |  systems.
     |
     |  :Character code: ``'Q'``
     |  :Canonical name: `numpy.uint`
     |  :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
     |  :Alias on this platform (win32 AMD64): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``.
     |
     |  Method resolution order:
     |      uint64
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint64.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint64(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class unsignedinteger(integer)
     |  Abstract base class of all unsigned integer scalar types.
     |
     |  Method resolution order:
     |      unsignedinteger
     |      integer
     |      number
     |      generic
     |      builtins.object
     |
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from number:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from generic:
     |
     |  __hash__ = None

    ushort = class uint16(unsignedinteger)
     |  Unsigned integer type, compatible with C ``unsigned short``.
     |
     |  :Character code: ``'H'``
     |  :Canonical name: `numpy.ushort`
     |  :Alias on this platform (win32 AMD64): `numpy.uint16`: 16-bit unsigned integer (``0`` to ``65_535``).
     |
     |  Method resolution order:
     |      uint16
     |      unsignedinteger
     |      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, /)
     |      True if self else False
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __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
     |
     |  __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.
     |
     |  bit_count(...)
     |      uint16.bit_count() -> int
     |
     |      Computes the number of 1-bits in the absolute value of the input.
     |      Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
     |
     |      Examples
     |      --------
     |      >>> np.uint16(127).bit_count()
     |      7
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      __class_getitem__(item, /)
     |
     |      Return a parametrized wrapper around the `~numpy.number` type.
     |
     |      .. versionadded:: 1.22
     |
     |      Returns
     |      -------
     |      alias : types.GenericAlias
     |          A parametrized `~numpy.number` type.
     |
     |      Examples
     |      --------
     |      >>> from typing import Any
     |      >>> import numpy as np
     |
     |      >>> np.signedinteger[Any]
     |      numpy.signedinteger[typing.Any]
     |
     |      See Also
     |      --------
     |      :pep:`585` : Type hinting generics in standard collections.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from integer:
     |
     |  __round__(...)
     |
     |  is_integer(...)
     |      integer.is_integer() -> bool
     |
     |      Return ``True`` if the number is finite with integral value.
     |
     |      .. versionadded:: 1.22
     |
     |      Examples
     |      --------
     |      >>> import numpy as np
     |      >>> np.int64(-2).is_integer()
     |      True
     |      >>> np.uint32(5).is_integer()
     |      True
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from integer:
     |
     |  denominator
     |      denominator of value (1)
     |
     |  numerator
     |      numerator of value (the value itself)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __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.
     |
     |  __setstate__(...)
     |
     |  __sizeof__(...)
     |      Size of object in memory, in bytes.
     |
     |  all(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  base
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.base`.
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  dtype
     |      Get array data-descriptor.
     |
     |  flags
     |      The integer value of flags.
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

    class vectorize(builtins.object)
     |  vectorize(pyfunc=<no value>, otypes=None, doc=None, excluded=None, cache=False, signature=None)
     |
     |  vectorize(pyfunc=np._NoValue, otypes=None, doc=None, excluded=None,
     |  cache=False, signature=None)
     |
     |  Returns an object that acts like pyfunc, but takes arrays as input.
     |
     |  Define a vectorized function which takes a nested sequence of objects or
     |  numpy arrays as inputs and returns a single numpy array or a tuple of numpy
     |  arrays. The vectorized function evaluates `pyfunc` over successive tuples
     |  of the input arrays like the python map function, except it uses the
     |  broadcasting rules of numpy.
     |
     |  The data type of the output of `vectorized` is determined by calling
     |  the function with the first element of the input.  This can be avoided
     |  by specifying the `otypes` argument.
     |
     |  Parameters
     |  ----------
     |  pyfunc : callable, optional
     |      A python function or method.
     |      Can be omitted to produce a decorator with keyword arguments.
     |  otypes : str or list of dtypes, optional
     |      The output data type. It must be specified as either a string of
     |      typecode characters or a list of data type specifiers. There should
     |      be one data type specifier for each output.
     |  doc : str, optional
     |      The docstring for the function. If None, the docstring will be the
     |      ``pyfunc.__doc__``.
     |  excluded : set, optional
     |      Set of strings or integers representing the positional or keyword
     |      arguments for which the function will not be vectorized.  These will be
     |      passed directly to `pyfunc` unmodified.
     |
     |      .. versionadded:: 1.7.0
     |
     |  cache : bool, optional
     |      If `True`, then cache the first function call that determines the number
     |      of outputs if `otypes` is not provided.
     |
     |      .. versionadded:: 1.7.0
     |
     |  signature : string, optional
     |      Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for
     |      vectorized matrix-vector multiplication. If provided, ``pyfunc`` will
     |      be called with (and expected to return) arrays with shapes given by the
     |      size of corresponding core dimensions. By default, ``pyfunc`` is
     |      assumed to take scalars as input and output.
     |
     |      .. versionadded:: 1.12.0
     |
     |  Returns
     |  -------
     |  out : callable
     |      A vectorized function if ``pyfunc`` was provided,
     |      a decorator otherwise.
     |
     |  See Also
     |  --------
     |  frompyfunc : Takes an arbitrary Python function and returns a ufunc
     |
     |  Notes
     |  -----
     |  The `vectorize` function is provided primarily for convenience, not for
     |  performance. The implementation is essentially a for loop.
     |
     |  If `otypes` is not specified, then a call to the function with the
     |  first argument will be used to determine the number of outputs.  The
     |  results of this call will be cached if `cache` is `True` to prevent
     |  calling the function twice.  However, to implement the cache, the
     |  original function must be wrapped which will slow down subsequent
     |  calls, so only do this if your function is expensive.
     |
     |  The new keyword argument interface and `excluded` argument support
     |  further degrades performance.
     |
     |  References
     |  ----------
     |  .. [1] :doc:`/reference/c-api/generalized-ufuncs`
     |
     |  Examples
     |  --------
     |  >>> import numpy as np
     |  >>> def myfunc(a, b):
     |  ...     "Return a-b if a>b, otherwise return a+b"
     |  ...     if a > b:
     |  ...         return a - b
     |  ...     else:
     |  ...         return a + b
     |
     |  >>> vfunc = np.vectorize(myfunc)
     |  >>> vfunc([1, 2, 3, 4], 2)
     |  array([3, 4, 1, 2])
     |
     |  The docstring is taken from the input function to `vectorize` unless it
     |  is specified:
     |
     |  >>> vfunc.__doc__
     |  'Return a-b if a>b, otherwise return a+b'
     |  >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
     |  >>> vfunc.__doc__
     |  'Vectorized `myfunc`'
     |
     |  The output type is determined by evaluating the first element of the input,
     |  unless it is specified:
     |
     |  >>> out = vfunc([1, 2, 3, 4], 2)
     |  >>> type(out[0])
     |  <class 'numpy.int64'>
     |  >>> vfunc = np.vectorize(myfunc, otypes=[float])
     |  >>> out = vfunc([1, 2, 3, 4], 2)
     |  >>> type(out[0])
     |  <class 'numpy.float64'>
     |
     |  The `excluded` argument can be used to prevent vectorizing over certain
     |  arguments.  This can be useful for array-like arguments of a fixed length
     |  such as the coefficients for a polynomial as in `polyval`:
     |
     |  >>> def mypolyval(p, x):
     |  ...     _p = list(p)
     |  ...     res = _p.pop(0)
     |  ...     while _p:
     |  ...         res = res*x + _p.pop(0)
     |  ...     return res
     |  >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
     |  >>> vpolyval(p=[1, 2, 3], x=[0, 1])
     |  array([3, 6])
     |
     |  Positional arguments may also be excluded by specifying their position:
     |
     |  >>> vpolyval.excluded.add(0)
     |  >>> vpolyval([1, 2, 3], x=[0, 1])
     |  array([3, 6])
     |
     |  The `signature` argument allows for vectorizing functions that act on
     |  non-scalar arrays of fixed length. For example, you can use it for a
     |  vectorized calculation of Pearson correlation coefficient and its p-value:
     |
     |  >>> import scipy.stats
     |  >>> pearsonr = np.vectorize(scipy.stats.pearsonr,
     |  ...                 signature='(n),(n)->(),()')
     |  >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
     |  (array([ 1., -1.]), array([ 0.,  0.]))
     |
     |  Or for a vectorized convolution:
     |
     |  >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
     |  >>> convolve(np.eye(4), [1, 2, 1])
     |  array([[1., 2., 1., 0., 0., 0.],
     |         [0., 1., 2., 1., 0., 0.],
     |         [0., 0., 1., 2., 1., 0.],
     |         [0., 0., 0., 1., 2., 1.]])
     |
     |  Decorator syntax is supported.  The decorator can be called as
     |  a function to provide keyword arguments:
     |
     |  >>> @np.vectorize
     |  ... def identity(x):
     |  ...     return x
     |  ...
     |  >>> identity([0, 1, 2])
     |  array([0, 1, 2])
     |  >>> @np.vectorize(otypes=[float])
     |  ... def as_float(x):
     |  ...     return x
     |  ...
     |  >>> as_float([0, 1, 2])
     |  array([0., 1., 2.])
     |
     |  Methods defined here:
     |
     |  __call__(self, *args, **kwargs) from numpy.lib._function_base_impl.vectorize
     |      Call self as a function.
     |
     |  __init__(self, pyfunc=<no value>, otypes=None, doc=None, excluded=None, cache=False, signature=None) from numpy.lib._function_base_impl.vectorize
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class void(flexible)
     |  np.void(length_or_data, /, dtype=None)
     |
     |  Create a new structured or unstructured void scalar.
     |
     |  Parameters
     |  ----------
     |  length_or_data : int, array-like, bytes-like, object
     |     One of multiple meanings (see notes).  The length or
     |     bytes data of an unstructured void.  Or alternatively,
     |     the data to be stored in the new scalar when `dtype`
     |     is provided.
     |     This can be an array-like, in which case an array may
     |     be returned.
     |  dtype : dtype, optional
     |     If provided the dtype of the new scalar.  This dtype must
     |     be "void" dtype (i.e. a structured or unstructured void,
     |     see also :ref:`defining-structured-types`).
     |
     |     .. versionadded:: 1.24
     |
     |  Notes
     |  -----
     |  For historical reasons and because void scalars can represent both
     |  arbitrary byte data and structured dtypes, the void constructor
     |  has three calling conventions:
     |
     |  1. ``np.void(5)`` creates a ``dtype="V5"`` scalar filled with five
     |     ``\0`` bytes.  The 5 can be a Python or NumPy integer.
     |  2. ``np.void(b"bytes-like")`` creates a void scalar from the byte string.
     |     The dtype itemsize will match the byte string length, here ``"V10"``.
     |  3. When a ``dtype=`` is passed the call is roughly the same as an
     |     array creation.  However, a void scalar rather than array is returned.
     |
     |  Please see the examples which show all three different conventions.
     |
     |  Examples
     |  --------
     |  >>> np.void(5)
     |  np.void(b'\x00\x00\x00\x00\x00')
     |  >>> np.void(b'abcd')
     |  np.void(b'\x61\x62\x63\x64')
     |  >>> np.void((3.2, b'eggs'), dtype="d,S5")
     |  np.void((3.2, b'eggs'), dtype=[('f0', '<f8'), ('f1', 'S5')])
     |  >>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)])
     |  np.void((3, 3), dtype=[('x', 'i1'), ('y', 'i1')])
     |
     |  :Character code: ``'V'``
     |
     |  Method resolution order:
     |      void
     |      flexible
     |      generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __buffer__(self, flags, /)
     |      Return a buffer object that exposes the underlying memory of the object.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  getfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.getfield`.
     |
     |  setfield(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setfield`.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  base
     |      base object
     |
     |  dtype
     |      dtype object
     |
     |  flags
     |      integer value of flags
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from generic:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __array__(...)
     |      sc.__array__(dtype) return 0-dim array from scalar with specified dtype
     |
     |  __array_namespace__(...)
     |
     |  __array_wrap__(...)
     |      sc.__array_wrap__(obj) return scalar from array
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __copy__(...)
     |
     |  __deepcopy__(...)
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      NumPy array scalar formatter
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(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.
     |
     |  __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__(...)
     |      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(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.all`.
     |
     |  any(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.any`.
     |
     |  argmax(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmax`.
     |
     |  argmin(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argmin`.
     |
     |  argsort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.argsort`.
     |
     |  astype(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.astype`.
     |
     |  byteswap(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.byteswap`.
     |
     |  choose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.choose`.
     |
     |  clip(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.clip`.
     |
     |  compress(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.compress`.
     |
     |  conj(...)
     |
     |  conjugate(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.conjugate`.
     |
     |  copy(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.copy`.
     |
     |  cumprod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumprod`.
     |
     |  cumsum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.cumsum`.
     |
     |  diagonal(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.diagonal`.
     |
     |  dump(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dump`.
     |
     |  dumps(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.dumps`.
     |
     |  fill(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.fill`.
     |
     |  flatten(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.flatten`.
     |
     |  item(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.item`.
     |
     |  max(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.max`.
     |
     |  mean(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.mean`.
     |
     |  min(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.min`.
     |
     |  nonzero(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.nonzero`.
     |
     |  prod(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.prod`.
     |
     |  put(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.put`.
     |
     |  ravel(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.ravel`.
     |
     |  repeat(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.repeat`.
     |
     |  reshape(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.reshape`.
     |
     |  resize(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.resize`.
     |
     |  round(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.round`.
     |
     |  searchsorted(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.searchsorted`.
     |
     |  setflags(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.setflags`.
     |
     |  sort(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sort`.
     |
     |  squeeze(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.squeeze`.
     |
     |  std(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.std`.
     |
     |  sum(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.sum`.
     |
     |  swapaxes(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.swapaxes`.
     |
     |  take(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.take`.
     |
     |  to_device(...)
     |
     |  tobytes(...)
     |
     |  tofile(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tofile`.
     |
     |  tolist(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tolist`.
     |
     |  tostring(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.tostring`.
     |
     |  trace(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.trace`.
     |
     |  transpose(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.transpose`.
     |
     |  var(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.var`.
     |
     |  view(...)
     |      Scalar method identical to the corresponding array attribute.
     |
     |      Please see `ndarray.view`.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from generic:
     |
     |  T
     |      Scalar attribute identical to the corresponding array attribute.
     |
     |      Please see `ndarray.T`.
     |
     |  __array_interface__
     |      Array protocol: Python side
     |
     |  __array_priority__
     |      Array priority.
     |
     |  __array_struct__
     |      Array protocol: struct
     |
     |  data
     |      Pointer to start of data.
     |
     |  device
     |
     |  flat
     |      A 1-D view of the scalar.
     |
     |  imag
     |      The imaginary part of the scalar.
     |
     |  itemset
     |
     |  itemsize
     |      The length of one element in bytes.
     |
     |  nbytes
     |
     |  ndim
     |      The number of array dimensions.
     |
     |  newbyteorder
     |
     |  ptp
     |
     |  real
     |      The real part of the scalar.
     |
     |  shape
     |      Tuple of array dimensions.
     |
     |  size
     |      The number of elements in the gentype.
     |
     |  strides
     |      Tuple of bytes steps in each dimension.

FUNCTIONS
    __dir__()

    __getattr__(attr)

    _get_promotion_state(...)
        Get the current NEP 50 promotion state.

    _no_nep50_warning()
        Context manager to disable NEP 50 warnings.  This context manager is
        only relevant if the NEP 50 warnings are enabled globally (which is not
        thread/context safe).

        This warning context manager itself is fully safe, however.

    _set_promotion_state(...)
        Set the NEP 50 promotion state.  This is not thread-safe.
        The optional warnings can be safely silenced using the
        `np._no_nep50_warning()` context manager.

    all(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)
        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 :ref:`ufuncs-output-type`
            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-class' method does not implement `keepdims` any
            exceptions will be raised.

        where : array_like of bool, optional
            Elements to include in checking for all `True` values.
            See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.20.0

        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.

        .. versionchanged:: 2.0
           Before NumPy 2.0, ``all`` did not return booleans for object dtype
           input arrays.
           This behavior is still available via ``np.logical_and.reduce``.

        Examples
        --------
        >>> import numpy as np
        >>> 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

        >>> np.all([[True, True], [False, True]], where=[[True], [False]])
        True

        >>> o=np.array(False)
        >>> z=np.all([-1, 4, 5], out=o)
        >>> id(z), id(o), z
        (28293632, 28293632, array(True)) # may vary

    allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)
        Returns True if two arrays are element-wise equal within a tolerance.

        The tolerance values are positive, typically very small numbers.  The
        relative difference (`rtol` * abs(`b`)) and the absolute difference
        `atol` are added together to compare against the absolute difference
        between `a` and `b`.

        .. warning:: The default `atol` is not appropriate for comparing numbers
                     with magnitudes much smaller than one (see Notes).

        NaNs are treated as equal if they are in the same place and if
        ``equal_nan=True``.  Infs are treated as equal if they are in the same
        place and of the same sign in both arrays.

        Parameters
        ----------
        a, b : array_like
            Input arrays to compare.
        rtol : array_like
            The relative tolerance parameter (see Notes).
        atol : array_like
            The absolute tolerance parameter (see Notes).
        equal_nan : bool
            Whether to compare NaN's as equal.  If True, NaN's in `a` will be
            considered equal to NaN's in `b` in the output array.

            .. versionadded:: 1.10.0

        Returns
        -------
        allclose : bool
            Returns True if the two arrays are equal within the given
            tolerance; False otherwise.

        See Also
        --------
        isclose, all, any, equal

        Notes
        -----
        If the following equation is element-wise True, then allclose returns
        True.::

         absolute(a - b) <= (atol + rtol * absolute(b))

        The above equation is not symmetric in `a` and `b`, so that
        ``allclose(a, b)`` might be different from ``allclose(b, a)`` in
        some rare cases.

        The default value of `atol` is not appropriate when the reference value
        `b` has magnitude smaller than one. For example, it is unlikely that
        ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet
        ``allclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure
        to select `atol` for the use case at hand, especially for defining the
        threshold below which a non-zero value in `a` will be considered "close"
        to a very small or zero value in `b`.

        The comparison of `a` and `b` uses standard broadcasting, which
        means that `a` and `b` need not have the same shape in order for
        ``allclose(a, b)`` to evaluate to True.  The same is true for
        `equal` but not `array_equal`.

        `allclose` is not defined for non-numeric data types.
        `bool` is considered a numeric data-type for this purpose.

        Examples
        --------
        >>> import numpy as np
        >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
        False

        >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
        True

        >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
        False

        >>> np.allclose([1.0, np.nan], [1.0, np.nan])
        False

        >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
        True

    amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the maximum of an array or maximum along an axis.

        `amax` is an alias of `~numpy.max`.

        See Also
        --------
        max : alias of this function
        ndarray.max : equivalent method

    amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the minimum of an array or minimum along an axis.

        `amin` is an alias of `~numpy.min`.

        See Also
        --------
        min : alias of this function
        ndarray.min : equivalent method

    angle(z, deg=False)
        Return the angle of the complex argument.

        Parameters
        ----------
        z : array_like
            A complex number or sequence of complex numbers.
        deg : bool, optional
            Return angle in degrees if True, radians if False (default).

        Returns
        -------
        angle : ndarray or scalar
            The counterclockwise angle from the positive real axis on the complex
            plane in the range ``(-pi, pi]``, with dtype as numpy.float64.

            .. versionchanged:: 1.16.0
                This function works on subclasses of ndarray like `ma.array`.

        See Also
        --------
        arctan2
        absolute

        Notes
        -----
        This function passes the imaginary and real parts of the argument to
        `arctan2` to compute the result; consequently, it follows the convention
        of `arctan2` when the magnitude of the argument is zero. See example.

        Examples
        --------
        >>> import numpy as np
        >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
        array([ 0.        ,  1.57079633,  0.78539816]) # may vary
        >>> np.angle(1+1j, deg=True)                  # in degrees
        45.0
        >>> np.angle([0., -0., complex(0., -0.), complex(-0., -0.)])  # convention
        array([ 0.        ,  3.14159265, -0.        , -3.14159265])

    any(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)
        Test whether any array element along a given axis evaluates to True.

        Returns single boolean if `axis` is ``None``

        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 OR reduction is performed.
            The default (``axis=None``) is to perform a logical OR 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 it is of type float, then it will remain so, returning
            1.0 for True and 0.0 for False, regardless of the type of `a`).
            See :ref:`ufuncs-output-type` 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 `any` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.

        where : array_like of bool, optional
            Elements to include in checking for any `True` values.
            See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.20.0

        Returns
        -------
        any : bool or ndarray
            A new boolean or `ndarray` is returned unless `out` is specified,
            in which case a reference to `out` is returned.

        See Also
        --------
        ndarray.any : equivalent method

        all : Test whether all elements along a given axis evaluate to True.

        Notes
        -----
        Not a Number (NaN), positive infinity and negative infinity evaluate
        to `True` because these are not equal to zero.

        .. versionchanged:: 2.0
           Before NumPy 2.0, ``any`` did not return booleans for object dtype
           input arrays.
           This behavior is still available via ``np.logical_or.reduce``.

        Examples
        --------
        >>> import numpy as np
        >>> np.any([[True, False], [True, True]])
        True

        >>> np.any([[True,  False, True ],
        ...         [False, False, False]], axis=0)
        array([ True, False, True])

        >>> np.any([-1, 0, 5])
        True

        >>> np.any([[np.nan], [np.inf]], axis=1, keepdims=True)
        array([[ True],
               [ True]])

        >>> np.any([[True, False], [False, False]], where=[[False], [True]])
        False

        >>> a = np.array([[1, 0, 0],
        ...               [0, 0, 1],
        ...               [0, 0, 0]])
        >>> np.any(a, axis=0)
        array([ True, False,  True])
        >>> np.any(a, axis=1)
        array([ True,  True, False])

        >>> o=np.array(False)
        >>> z=np.any([-1, 4, 5], out=o)
        >>> z, o
        (array(True), array(True))
        >>> # Check now that z is a reference to o
        >>> z is o
        True
        >>> id(z), id(o) # identity of z and o              # doctest: +SKIP
        (191614240, 191614240)

    append(arr, values, axis=None)
        Append values to the end of an array.

        Parameters
        ----------
        arr : array_like
            Values are appended to a copy of this array.
        values : array_like
            These values are appended to a copy of `arr`.  It must be of the
            correct shape (the same shape as `arr`, excluding `axis`).  If
            `axis` is not specified, `values` can be any shape and will be
            flattened before use.
        axis : int, optional
            The axis along which `values` are appended.  If `axis` is not
            given, both `arr` and `values` are flattened before use.

        Returns
        -------
        append : ndarray
            A copy of `arr` with `values` appended to `axis`.  Note that
            `append` does not occur in-place: a new array is allocated and
            filled.  If `axis` is None, `out` is a flattened array.

        See Also
        --------
        insert : Insert elements into an array.
        delete : Delete elements from an array.

        Examples
        --------
        >>> import numpy as np
        >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
        array([1, 2, 3, ..., 7, 8, 9])

        When `axis` is specified, `values` must have the correct shape.

        >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
        array([[1, 2, 3],
               [4, 5, 6],
               [7, 8, 9]])

        >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
        Traceback (most recent call last):
            ...
        ValueError: all the input arrays must have same number of dimensions, but
        the array at index 0 has 2 dimension(s) and the array at index 1 has 1
        dimension(s)

        >>> a = np.array([1, 2], dtype=int)
        >>> c = np.append(a, [])
        >>> c
        array([1., 2.])
        >>> c.dtype
        float64

        Default dtype for empty ndarrays is `float64` thus making the output of dtype
        `float64` when appended with dtype `int64`

    apply_along_axis(func1d, axis, arr, *args, **kwargs)
        Apply a function to 1-D slices along the given axis.

        Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays
        and `a` is a 1-D slice of `arr` along `axis`.

        This is equivalent to (but faster than) the following use of `ndindex` and
        `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::

            Ni, Nk = a.shape[:axis], a.shape[axis+1:]
            for ii in ndindex(Ni):
                for kk in ndindex(Nk):
                    f = func1d(arr[ii + s_[:,] + kk])
                    Nj = f.shape
                    for jj in ndindex(Nj):
                        out[ii + jj + kk] = f[jj]

        Equivalently, eliminating the inner loop, this can be expressed as::

            Ni, Nk = a.shape[:axis], a.shape[axis+1:]
            for ii in ndindex(Ni):
                for kk in ndindex(Nk):
                    out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])

        Parameters
        ----------
        func1d : function (M,) -> (Nj...)
            This function should accept 1-D arrays. It is applied to 1-D
            slices of `arr` along the specified axis.
        axis : integer
            Axis along which `arr` is sliced.
        arr : ndarray (Ni..., M, Nk...)
            Input array.
        args : any
            Additional arguments to `func1d`.
        kwargs : any
            Additional named arguments to `func1d`.

            .. versionadded:: 1.9.0


        Returns
        -------
        out : ndarray  (Ni..., Nj..., Nk...)
            The output array. The shape of `out` is identical to the shape of
            `arr`, except along the `axis` dimension. This axis is removed, and
            replaced with new dimensions equal to the shape of the return value
            of `func1d`. So if `func1d` returns a scalar `out` will have one
            fewer dimensions than `arr`.

        See Also
        --------
        apply_over_axes : Apply a function repeatedly over multiple axes.

        Examples
        --------
        >>> import numpy as np
        >>> def my_func(a):
        ...     """Average first and last element of a 1-D array"""
        ...     return (a[0] + a[-1]) * 0.5
        >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
        >>> np.apply_along_axis(my_func, 0, b)
        array([4., 5., 6.])
        >>> np.apply_along_axis(my_func, 1, b)
        array([2.,  5.,  8.])

        For a function that returns a 1D array, the number of dimensions in
        `outarr` is the same as `arr`.

        >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
        >>> np.apply_along_axis(sorted, 1, b)
        array([[1, 7, 8],
               [3, 4, 9],
               [2, 5, 6]])

        For a function that returns a higher dimensional array, those dimensions
        are inserted in place of the `axis` dimension.

        >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
        >>> np.apply_along_axis(np.diag, -1, b)
        array([[[1, 0, 0],
                [0, 2, 0],
                [0, 0, 3]],
               [[4, 0, 0],
                [0, 5, 0],
                [0, 0, 6]],
               [[7, 0, 0],
                [0, 8, 0],
                [0, 0, 9]]])

    apply_over_axes(func, a, axes)
        Apply a function repeatedly over multiple axes.

        `func` is called as `res = func(a, axis)`, where `axis` is the first
        element of `axes`.  The result `res` of the function call must have
        either the same dimensions as `a` or one less dimension.  If `res`
        has one less dimension than `a`, a dimension is inserted before
        `axis`.  The call to `func` is then repeated for each axis in `axes`,
        with `res` as the first argument.

        Parameters
        ----------
        func : function
            This function must take two arguments, `func(a, axis)`.
        a : array_like
            Input array.
        axes : array_like
            Axes over which `func` is applied; the elements must be integers.

        Returns
        -------
        apply_over_axis : ndarray
            The output array.  The number of dimensions is the same as `a`,
            but the shape can be different.  This depends on whether `func`
            changes the shape of its output with respect to its input.

        See Also
        --------
        apply_along_axis :
            Apply a function to 1-D slices of an array along the given axis.

        Notes
        -----
        This function is equivalent to tuple axis arguments to reorderable ufuncs
        with keepdims=True. Tuple axis arguments to ufuncs have been available since
        version 1.7.0.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(24).reshape(2,3,4)
        >>> a
        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]]])

        Sum over axes 0 and 2. The result has same number of dimensions
        as the original array:

        >>> np.apply_over_axes(np.sum, a, [0,2])
        array([[[ 60],
                [ 92],
                [124]]])

        Tuple axis arguments to ufuncs are equivalent:

        >>> np.sum(a, axis=(0,2), keepdims=True)
        array([[[ 60],
                [ 92],
                [124]]])

    arange(...)
        arange([start,] stop[, step,], dtype=None, *, device=None, like=None)

        Return evenly spaced values within a given interval.

        ``arange`` can be called with a varying number of positional arguments:

        * ``arange(stop)``: Values are generated within the half-open interval
          ``[0, stop)`` (in other words, the interval including `start` but
          excluding `stop`).
        * ``arange(start, stop)``: Values are generated within the half-open
          interval ``[start, stop)``.
        * ``arange(start, stop, step)`` Values are generated within the half-open
          interval ``[start, stop)``, with spacing between values given by
          ``step``.

        For integer arguments the function is roughly equivalent to the Python
        built-in :py:class:`range`, but returns an ndarray rather than a ``range``
        instance.

        When using a non-integer step, such as 0.1, it is often better to use
        `numpy.linspace`.

        See the Warning sections below for more information.

        Parameters
        ----------
        start : integer or real, optional
            Start of interval.  The interval includes this value.  The default
            start value is 0.
        stop : integer or real
            End of interval.  The interval does not include this value, except
            in some cases where `step` is not an integer and floating point
            round-off affects the length of `out`.
        step : integer or real, optional
            Spacing between values.  For any output `out`, this is the distance
            between two adjacent values, ``out[i+1] - out[i]``.  The default
            step size is 1.  If `step` is specified as a position argument,
            `start` must also be given.
        dtype : dtype, optional
            The type of the output array.  If `dtype` is not given, infer the data
            type from the other input arguments.
        device : str, optional
            The device on which to place the created array. Default: ``None``.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        arange : ndarray
            Array of evenly spaced values.

            For floating point arguments, the length of the result is
            ``ceil((stop - start)/step)``.  Because of floating point overflow,
            this rule may result in the last element of `out` being greater
            than `stop`.

        Warnings
        --------
        The length of the output might not be numerically stable.

        Another stability issue is due to the internal implementation of
        `numpy.arange`.
        The actual step value used to populate the array is
        ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss
        can occur here, due to casting or due to using floating points when
        `start` is much larger than `step`. This can lead to unexpected
        behaviour. For example::

          >>> np.arange(0, 5, 0.5, dtype=int)
          array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
          >>> np.arange(-3, 3, 0.5, dtype=int)
          array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

        In such cases, the use of `numpy.linspace` should be preferred.

        The built-in :py:class:`range` generates :std:doc:`Python built-in integers
        that have arbitrary size <python:c-api/long>`, while `numpy.arange`
        produces `numpy.int32` or `numpy.int64` numbers. This may result in
        incorrect results for large integer values::

          >>> power = 40
          >>> modulo = 10000
          >>> x1 = [(n ** power) % modulo for n in range(8)]
          >>> x2 = [(n ** power) % modulo for n in np.arange(8)]
          >>> print(x1)
          [0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct
          >>> print(x2)
          [0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect

        See Also
        --------
        numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
        numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
        numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
        :ref:`how-to-partition`

        Examples
        --------
        >>> import numpy as np
        >>> np.arange(3)
        array([0, 1, 2])
        >>> np.arange(3.0)
        array([ 0.,  1.,  2.])
        >>> np.arange(3,7)
        array([3, 4, 5, 6])
        >>> np.arange(3,7,2)
        array([3, 5])

    argmax(a, axis=None, out=None, *, keepdims=<no value>)
        Returns the indices of the maximum values along an axis.

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int, optional
            By default, the index is into the flattened array, otherwise
            along the specified axis.
        out : array, optional
            If provided, the result will be inserted into this array. It should
            be of the appropriate shape and dtype.
        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 array.

            .. versionadded:: 1.22.0

        Returns
        -------
        index_array : ndarray of ints
            Array of indices into the array. It has the same shape as ``a.shape``
            with the dimension along `axis` removed. If `keepdims` is set to True,
            then the size of `axis` will be 1 with the resulting array having same
            shape as ``a.shape``.

        See Also
        --------
        ndarray.argmax, argmin
        amax : The maximum value along a given axis.
        unravel_index : Convert a flat index into an index tuple.
        take_along_axis : Apply ``np.expand_dims(index_array, axis)``
                          from argmax to an array as if by calling max.

        Notes
        -----
        In case of multiple occurrences of the maximum values, the indices
        corresponding to the first occurrence are returned.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(6).reshape(2,3) + 10
        >>> a
        array([[10, 11, 12],
               [13, 14, 15]])
        >>> np.argmax(a)
        5
        >>> np.argmax(a, axis=0)
        array([1, 1, 1])
        >>> np.argmax(a, axis=1)
        array([2, 2])

        Indexes of the maximal elements of a N-dimensional array:

        >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)
        >>> ind
        (1, 2)
        >>> a[ind]
        15

        >>> b = np.arange(6)
        >>> b[1] = 5
        >>> b
        array([0, 5, 2, 3, 4, 5])
        >>> np.argmax(b)  # Only the first occurrence is returned.
        1

        >>> x = np.array([[4,2,3], [1,0,3]])
        >>> index_array = np.argmax(x, axis=-1)
        >>> # Same as np.amax(x, axis=-1, keepdims=True)
        >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
        array([[4],
               [3]])
        >>> # Same as np.amax(x, axis=-1)
        >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1),
        ...     axis=-1).squeeze(axis=-1)
        array([4, 3])

        Setting `keepdims` to `True`,

        >>> x = np.arange(24).reshape((2, 3, 4))
        >>> res = np.argmax(x, axis=1, keepdims=True)
        >>> res.shape
        (2, 1, 4)

    argmin(a, axis=None, out=None, *, keepdims=<no value>)
        Returns the indices of the minimum values along an axis.

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int, optional
            By default, the index is into the flattened array, otherwise
            along the specified axis.
        out : array, optional
            If provided, the result will be inserted into this array. It should
            be of the appropriate shape and dtype.
        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 array.

            .. versionadded:: 1.22.0

        Returns
        -------
        index_array : ndarray of ints
            Array of indices into the array. It has the same shape as `a.shape`
            with the dimension along `axis` removed. If `keepdims` is set to True,
            then the size of `axis` will be 1 with the resulting array having same
            shape as `a.shape`.

        See Also
        --------
        ndarray.argmin, argmax
        amin : The minimum value along a given axis.
        unravel_index : Convert a flat index into an index tuple.
        take_along_axis : Apply ``np.expand_dims(index_array, axis)``
                          from argmin to an array as if by calling min.

        Notes
        -----
        In case of multiple occurrences of the minimum values, the indices
        corresponding to the first occurrence are returned.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(6).reshape(2,3) + 10
        >>> a
        array([[10, 11, 12],
               [13, 14, 15]])
        >>> np.argmin(a)
        0
        >>> np.argmin(a, axis=0)
        array([0, 0, 0])
        >>> np.argmin(a, axis=1)
        array([0, 0])

        Indices of the minimum elements of a N-dimensional array:

        >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape)
        >>> ind
        (0, 0)
        >>> a[ind]
        10

        >>> b = np.arange(6) + 10
        >>> b[4] = 10
        >>> b
        array([10, 11, 12, 13, 10, 15])
        >>> np.argmin(b)  # Only the first occurrence is returned.
        0

        >>> x = np.array([[4,2,3], [1,0,3]])
        >>> index_array = np.argmin(x, axis=-1)
        >>> # Same as np.amin(x, axis=-1, keepdims=True)
        >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
        array([[2],
               [0]])
        >>> # Same as np.amax(x, axis=-1)
        >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1),
        ...     axis=-1).squeeze(axis=-1)
        array([2, 0])

        Setting `keepdims` to `True`,

        >>> x = np.arange(24).reshape((2, 3, 4))
        >>> res = np.argmin(x, axis=1, keepdims=True)
        >>> res.shape
        (2, 1, 4)

    argpartition(a, kth, axis=-1, kind='introselect', order=None)
        Perform an indirect partition 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 partitioned order.

        .. versionadded:: 1.8.0

        Parameters
        ----------
        a : array_like
            Array to sort.
        kth : int or sequence of ints
            Element index to partition by. The k-th element will be in its
            final sorted position and all smaller elements will be moved
            before it and all larger elements behind it. The order of all
            elements in the partitions is undefined. If provided with a
            sequence of k-th it will partition all of them into their sorted
            position at once.

            .. deprecated:: 1.22.0
                Passing booleans as index is deprecated.
        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 : {'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.

        Returns
        -------
        index_array : ndarray, int
            Array of indices that partition `a` along the specified axis.
            If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
            More generally, ``np.take_along_axis(a, index_array, axis=axis)``
            always yields the partitioned `a`, irrespective of dimensionality.

        See Also
        --------
        partition : Describes partition algorithms used.
        ndarray.partition : Inplace partition.
        argsort : Full indirect sort.
        take_along_axis : Apply ``index_array`` from argpartition
                          to an array as if by calling partition.

        Notes
        -----
        The returned indices are not guaranteed to be sorted according to
        the values. Furthermore, the default selection algorithm ``introselect``
        is unstable, and hence the returned indices are not guaranteed
        to be the earliest/latest occurrence of the element.

        `argpartition` works for real/complex inputs with nan values,
        see `partition` for notes on the enhanced sort order and
        different selection algorithms.

        Examples
        --------
        One dimensional array:

        >>> import numpy as np
        >>> x = np.array([3, 4, 2, 1])
        >>> x[np.argpartition(x, 3)]
        array([2, 1, 3, 4]) # may vary
        >>> x[np.argpartition(x, (1, 3))]
        array([1, 2, 3, 4]) # may vary

        >>> x = [3, 4, 2, 1]
        >>> np.array(x)[np.argpartition(x, 3)]
        array([2, 1, 3, 4]) # may vary

        Multi-dimensional array:

        >>> x = np.array([[3, 4, 2], [1, 3, 1]])
        >>> index_array = np.argpartition(x, kth=1, axis=-1)
        >>> # below is the same as np.partition(x, kth=1)
        >>> np.take_along_axis(x, index_array, axis=-1)
        array([[2, 3, 4],
               [1, 1, 3]])

    argsort(a, axis=-1, kind=None, order=None, *, stable=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', 'stable'}, optional
            Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
            and 'mergesort' use timsort under the covers and, in general, the
            actual implementation will vary with data type. The 'mergesort' option
            is retained for backwards compatibility.

            .. versionchanged:: 1.15.0.
               The 'stable' option was added.
        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.
        stable : bool, optional
            Sort stability. If ``True``, the returned array will maintain
            the relative order of ``a`` values which compare as equal.
            If ``False`` or ``None``, this is not guaranteed. Internally,
            this option selects ``kind='stable'``. Default: ``None``.

            .. versionadded:: 2.0.0

        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`.
            More generally, ``np.take_along_axis(a, index_array, axis=axis)``
            always yields the sorted `a`, irrespective of dimensionality.

        See Also
        --------
        sort : Describes sorting algorithms used.
        lexsort : Indirect stable sort with multiple keys.
        ndarray.sort : Inplace sort.
        argpartition : Indirect partial sort.
        take_along_axis : Apply ``index_array`` from argsort
                          to an array as if by calling 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:

        >>> import numpy as np
        >>> 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]])

        >>> ind = np.argsort(x, axis=0)  # sorts along first axis (down)
        >>> ind
        array([[0, 1],
               [1, 0]])
        >>> np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
        array([[0, 2],
               [2, 3]])

        >>> ind = np.argsort(x, axis=1)  # sorts along last axis (across)
        >>> ind
        array([[0, 1],
               [0, 1]])
        >>> np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
        array([[0, 3],
               [2, 2]])

        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])

    argwhere(a)
        Find the indices of array elements that are non-zero, grouped by element.

        Parameters
        ----------
        a : array_like
            Input data.

        Returns
        -------
        index_array : (N, a.ndim) ndarray
            Indices of elements that are non-zero. Indices are grouped by element.
            This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
            non-zero items.

        See Also
        --------
        where, nonzero

        Notes
        -----
        ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
        but produces a result of the correct shape for a 0D array.

        The output of ``argwhere`` is not suitable for indexing arrays.
        For this purpose use ``nonzero(a)`` instead.

        Examples
        --------
        >>> import numpy as np
        >>> 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]])

    around(a, decimals=0, out=None)
        Round an array to the given number of decimals.

        `around` is an alias of `~numpy.round`.

        See Also
        --------
        ndarray.round : equivalent method
        round : alias for this function
        ceil, fix, floor, rint, trunc

    array(...)
        array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,
              like=None)

        Create an array.

        Parameters
        ----------
        object : array_like
            An array, any object exposing the array interface, an object whose
            ``__array__`` method returns an array, or any (nested) sequence.
            If object is a scalar, a 0-dimensional array containing object is
            returned.
        dtype : data-type, optional
            The desired data-type for the array. If not given, NumPy will try to use
            a default ``dtype`` that can represent the values (by applying promotion
            rules when necessary.)
        copy : bool, optional
            If ``True`` (default), then the array data is copied. If ``None``,
            a copy will only be made if ``__array__`` returns a copy, if obj is
            a nested sequence, or if a copy is needed to satisfy any of the other
            requirements (``dtype``, ``order``, etc.). Note that any copy of
            the data is shallow, i.e., for arrays with object dtype, the new
            array will point to the same objects. See Examples for `ndarray.copy`.
            For ``False`` it raises a ``ValueError`` if a copy cannot be avoided.
            Default: ``True``.
        order : {'K', 'A', 'C', 'F'}, optional
            Specify the memory layout of the array. If object is not an array, the
            newly created array will be in C order (row major) unless 'F' is
            specified, in which case it will be in Fortran order (column major).
            If object is an array the following holds.

            ===== ========= ===================================================
            order  no copy                     copy=True
            ===== ========= ===================================================
            'K'   unchanged F & C order preserved, otherwise most similar order
            'A'   unchanged F order if input is F and not C, otherwise C order
            'C'   C order   C order
            'F'   F order   F order
            ===== ========= ===================================================

            When ``copy=None`` and a copy is made for other reasons, the result is
            the same as if ``copy=True``, with some exceptions for 'A', see the
            Notes section. The default order is 'K'.
        subok : bool, optional
            If True, then sub-classes will be passed-through, otherwise
            the returned array will be forced to be a base-class array (default).
        ndmin : int, optional
            Specifies the minimum number of dimensions that the resulting
            array should have.  Ones will be prepended to the shape as
            needed to meet this requirement.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            An array object satisfying the specified requirements.

        See Also
        --------
        empty_like : Return an empty array with shape and type of input.
        ones_like : Return an array of ones with shape and type of input.
        zeros_like : Return an array of zeros with shape and type of input.
        full_like : Return a new array with shape of input filled with value.
        empty : Return a new uninitialized array.
        ones : Return a new array setting values to one.
        zeros : Return a new array setting values to zero.
        full : Return a new array of given shape filled with value.
        copy: Return an array copy of the given object.


        Notes
        -----
        When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order,
        and a copy is forced by a change in dtype, then the order of the result is
        not necessarily 'C' as expected. This is likely a bug.

        Examples
        --------
        >>> import numpy as np
        >>> np.array([1, 2, 3])
        array([1, 2, 3])

        Upcasting:

        >>> np.array([1, 2, 3.0])
        array([ 1.,  2.,  3.])

        More than one dimension:

        >>> np.array([[1, 2], [3, 4]])
        array([[1, 2],
               [3, 4]])

        Minimum dimensions 2:

        >>> np.array([1, 2, 3], ndmin=2)
        array([[1, 2, 3]])

        Type provided:

        >>> np.array([1, 2, 3], dtype=complex)
        array([ 1.+0.j,  2.+0.j,  3.+0.j])

        Data-type consisting of more than one element:

        >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
        >>> x['a']
        array([1, 3])

        Creating an array from sub-classes:

        >>> np.array(np.asmatrix('1 2; 3 4'))
        array([[1, 2],
               [3, 4]])

        >>> np.array(np.asmatrix('1 2; 3 4'), subok=True)
        matrix([[1, 2],
                [3, 4]])

    array2string(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', style=<no value>, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', *, legacy=None)
        Return a string representation of an array.

        Parameters
        ----------
        a : ndarray
            Input array.
        max_line_width : int, optional
            Inserts newlines if text is longer than `max_line_width`.
            Defaults to ``numpy.get_printoptions()['linewidth']``.
        precision : int or None, optional
            Floating point precision.
            Defaults to ``numpy.get_printoptions()['precision']``.
        suppress_small : bool, optional
            Represent numbers "very close" to zero as zero; default is False.
            Very close is defined by precision: if the precision is 8, e.g.,
            numbers smaller (in absolute value) than 5e-9 are represented as
            zero.
            Defaults to ``numpy.get_printoptions()['suppress']``.
        separator : str, optional
            Inserted between elements.
        prefix : str, optional
        suffix : str, optional
            The length of the prefix and suffix strings are used to respectively
            align and wrap the output. An array is typically printed as::

              prefix + array2string(a) + suffix

            The output is left-padded by the length of the prefix string, and
            wrapping is forced at the column ``max_line_width - len(suffix)``.
            It should be noted that the content of prefix and suffix strings are
            not included in the output.
        style : _NoValue, optional
            Has no effect, do not use.

            .. deprecated:: 1.14.0
        formatter : dict of callables, optional
            If not None, the keys should indicate the type(s) that the respective
            formatting function applies to.  Callables should return a string.
            Types that are not specified (by their corresponding keys) are handled
            by the default formatters.  Individual types for which a formatter
            can be set are:

            - 'bool'
            - 'int'
            - 'timedelta' : a `numpy.timedelta64`
            - 'datetime' : a `numpy.datetime64`
            - 'float'
            - 'longfloat' : 128-bit floats
            - 'complexfloat'
            - 'longcomplexfloat' : composed of two 128-bit floats
            - 'void' : type `numpy.void`
            - 'numpystr' : types `numpy.bytes_` and `numpy.str_`

            Other keys that can be used to set a group of types at once are:

            - 'all' : sets all types
            - 'int_kind' : sets 'int'
            - 'float_kind' : sets 'float' and 'longfloat'
            - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
            - 'str_kind' : sets 'numpystr'
        threshold : int, optional
            Total number of array elements which trigger summarization
            rather than full repr.
            Defaults to ``numpy.get_printoptions()['threshold']``.
        edgeitems : int, optional
            Number of array items in summary at beginning and end of
            each dimension.
            Defaults to ``numpy.get_printoptions()['edgeitems']``.
        sign : string, either '-', '+', or ' ', optional
            Controls printing of the sign of floating-point types. If '+', always
            print the sign of positive values. If ' ', always prints a space
            (whitespace character) in the sign position of positive values.  If
            '-', omit the sign character of positive values.
            Defaults to ``numpy.get_printoptions()['sign']``.

            .. versionchanged:: 2.0
                 The sign parameter can now be an integer type, previously
                 types were floating-point types.

        floatmode : str, optional
            Controls the interpretation of the `precision` option for
            floating-point types.
            Defaults to ``numpy.get_printoptions()['floatmode']``.
            Can take the following values:

            - 'fixed': Always print exactly `precision` fractional digits,
              even if this would print more or fewer digits than
              necessary to specify the value uniquely.
            - 'unique': Print the minimum number of fractional digits necessary
              to represent each value uniquely. Different elements may
              have a different number of digits.  The value of the
              `precision` option is ignored.
            - 'maxprec': Print at most `precision` fractional digits, but if
              an element can be uniquely represented with fewer digits
              only print it with that many.
            - 'maxprec_equal': Print at most `precision` fractional digits,
              but if every element in the array can be uniquely
              represented with an equal number of fewer digits, use that
              many digits for all elements.
        legacy : string or `False`, optional
            If set to the string ``'1.13'`` enables 1.13 legacy printing mode. This
            approximates numpy 1.13 print output by including a space in the sign
            position of floats and different behavior for 0d arrays. If set to
            `False`, disables legacy mode. Unrecognized strings will be ignored
            with a warning for forward compatibility.

            .. versionadded:: 1.14.0

        Returns
        -------
        array_str : str
            String representation of the array.

        Raises
        ------
        TypeError
            if a callable in `formatter` does not return a string.

        See Also
        --------
        array_str, array_repr, set_printoptions, get_printoptions

        Notes
        -----
        If a formatter is specified for a certain type, the `precision` keyword is
        ignored for that type.

        This is a very flexible function; `array_repr` and `array_str` are using
        `array2string` internally so keywords with the same name should work
        identically in all three functions.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([1e-16,1,2,3])
        >>> np.array2string(x, precision=2, separator=',',
        ...                       suppress_small=True)
        '[0.,1.,2.,3.]'

        >>> x  = np.arange(3.)
        >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
        '[0.00 1.00 2.00]'

        >>> x  = np.arange(3)
        >>> np.array2string(x, formatter={'int':lambda x: hex(x)})
        '[0x0 0x1 0x2]'

    array_equal(a1, a2, equal_nan=False)
        True if two arrays have the same shape and elements, False otherwise.

        Parameters
        ----------
        a1, a2 : array_like
            Input arrays.
        equal_nan : bool
            Whether to compare NaN's as equal. If the dtype of a1 and a2 is
            complex, values will be considered equal if either the real or the
            imaginary component of a given value is ``nan``.

            .. versionadded:: 1.19.0

        Returns
        -------
        b : bool
            Returns True if the arrays are equal.

        See Also
        --------
        allclose: Returns True if two arrays are element-wise equal within a
                  tolerance.
        array_equiv: Returns True if input arrays are shape consistent and all
                     elements equal.

        Examples
        --------
        >>> import numpy as np

        >>> np.array_equal([1, 2], [1, 2])
        True

        >>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
        True

        >>> np.array_equal([1, 2], [1, 2, 3])
        False

        >>> np.array_equal([1, 2], [1, 4])
        False

        >>> a = np.array([1, np.nan])
        >>> np.array_equal(a, a)
        False

        >>> np.array_equal(a, a, equal_nan=True)
        True

        When ``equal_nan`` is True, complex values with nan components are
        considered equal if either the real *or* the imaginary components are nan.

        >>> a = np.array([1 + 1j])
        >>> b = a.copy()
        >>> a.real = np.nan
        >>> b.imag = np.nan
        >>> np.array_equal(a, b, equal_nan=True)
        True

    array_equiv(a1, a2)
        Returns True if input arrays are shape consistent and all elements equal.

        Shape consistent means they are either the same shape, or one input array
        can be broadcasted to create the same shape as the other one.

        Parameters
        ----------
        a1, a2 : array_like
            Input arrays.

        Returns
        -------
        out : bool
            True if equivalent, False otherwise.

        Examples
        --------
        >>> import numpy as np
        >>> np.array_equiv([1, 2], [1, 2])
        True
        >>> np.array_equiv([1, 2], [1, 3])
        False

        Showing the shape equivalence:

        >>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
        True
        >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
        False

        >>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
        False

    array_repr(arr, max_line_width=None, precision=None, suppress_small=None)
        Return the string representation of an array.

        Parameters
        ----------
        arr : ndarray
            Input array.
        max_line_width : int, optional
            Inserts newlines if text is longer than `max_line_width`.
            Defaults to ``numpy.get_printoptions()['linewidth']``.
        precision : int, optional
            Floating point precision.
            Defaults to ``numpy.get_printoptions()['precision']``.
        suppress_small : bool, optional
            Represent numbers "very close" to zero as zero; default is False.
            Very close is defined by precision: if the precision is 8, e.g.,
            numbers smaller (in absolute value) than 5e-9 are represented as
            zero.
            Defaults to ``numpy.get_printoptions()['suppress']``.

        Returns
        -------
        string : str
          The string representation of an array.

        See Also
        --------
        array_str, array2string, set_printoptions

        Examples
        --------
        >>> import numpy as np
        >>> np.array_repr(np.array([1,2]))
        'array([1, 2])'
        >>> np.array_repr(np.ma.array([0.]))
        'MaskedArray([0.])'
        >>> np.array_repr(np.array([], np.int32))
        'array([], dtype=int32)'

        >>> x = np.array([1e-6, 4e-7, 2, 3])
        >>> np.array_repr(x, precision=6, suppress_small=True)
        'array([0.000001,  0.      ,  2.      ,  3.      ])'

    array_split(ary, indices_or_sections, axis=0)
        Split an array into multiple sub-arrays.

        Please refer to the ``split`` documentation.  The only difference
        between these functions is that ``array_split`` allows
        `indices_or_sections` to be an integer that does *not* equally
        divide the axis. For an array of length l that should be split
        into n sections, it returns l % n sub-arrays of size l//n + 1
        and the rest of size l//n.

        See Also
        --------
        split : Split array into multiple sub-arrays of equal size.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(8.0)
        >>> np.array_split(x, 3)
        [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.])]

        >>> x = np.arange(9)
        >>> np.array_split(x, 4)
        [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]

    array_str(a, max_line_width=None, precision=None, suppress_small=None)
        Return a string representation of the data in an array.

        The data in the array is returned as a single string.  This function is
        similar to `array_repr`, the difference being that `array_repr` also
        returns information on the kind of array and its data type.

        Parameters
        ----------
        a : ndarray
            Input array.
        max_line_width : int, optional
            Inserts newlines if text is longer than `max_line_width`.
            Defaults to ``numpy.get_printoptions()['linewidth']``.
        precision : int, optional
            Floating point precision.
            Defaults to ``numpy.get_printoptions()['precision']``.
        suppress_small : bool, optional
            Represent numbers "very close" to zero as zero; default is False.
            Very close is defined by precision: if the precision is 8, e.g.,
            numbers smaller (in absolute value) than 5e-9 are represented as
            zero.
            Defaults to ``numpy.get_printoptions()['suppress']``.

        See Also
        --------
        array2string, array_repr, set_printoptions

        Examples
        --------
        >>> import numpy as np
        >>> np.array_str(np.arange(3))
        '[0 1 2]'

    asanyarray(...)
        asanyarray(a, dtype=None, order=None, *, like=None)

        Convert the input to an ndarray, but pass ndarray subclasses through.

        Parameters
        ----------
        a : array_like
            Input data, in any form that can be converted to an array.  This
            includes scalars, 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', 'A', 'K'}, optional
            Memory layout.  'A' and 'K' depend on the order of input array a.
            'C' row-major (C-style),
            'F' column-major (Fortran-style) memory representation.
            'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
            'K' (keep) preserve input order
            Defaults to 'C'.
        device : str, optional
            The device on which to place the created array. Default: ``None``.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.1.0

        copy : bool, optional
            If ``True``, then the object is copied. If ``None`` then the object is
            copied only if needed, i.e. if ``__array__`` returns a copy, if obj
            is a nested sequence, or if a copy is needed to satisfy any of
            the other requirements (``dtype``, ``order``, etc.).
            For ``False`` it raises a ``ValueError`` if a copy cannot be avoided.
            Default: ``None``.

            .. versionadded:: 2.1.0

        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray or an ndarray subclass
            Array interpretation of `a`.  If `a` is an ndarray or a subclass
            of ndarray, it is returned as-is and no copy is performed.

        See Also
        --------
        asarray : Similar function which always returns ndarrays.
        ascontiguousarray : Convert input to a contiguous array.
        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]
        >>> import numpy as np
        >>> np.asanyarray(a)
        array([1, 2])

        Instances of `ndarray` subclasses are passed through as-is:

        >>> a = np.array([(1., 2), (3., 4)], dtype='f4,i4').view(np.recarray)
        >>> np.asanyarray(a) is a
        True

    asarray(...)
        asarray(a, dtype=None, order=None, *, device=None, copy=None, like=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', 'A', 'K'}, optional
            Memory layout.  'A' and 'K' depend on the order of input array a.
            'C' row-major (C-style),
            'F' column-major (Fortran-style) memory representation.
            'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
            'K' (keep) preserve input order
            Defaults to 'K'.
        device : str, optional
            The device on which to place the created array. Default: ``None``.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0
        copy : bool, optional
            If ``True``, then the object is copied. If ``None`` then the object is
            copied only if needed, i.e. if ``__array__`` returns a copy, if obj
            is a nested sequence, or if a copy is needed to satisfy any of
            the other requirements (``dtype``, ``order``, etc.).
            For ``False`` it raises a ``ValueError`` if a copy cannot be avoided.
            Default: ``None``.

            .. versionadded:: 2.0.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        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.
        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]
        >>> import numpy as np
        >>> 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.shares_memory(np.asarray(a, dtype=np.float32), a)
        True
        >>> np.shares_memory(np.asarray(a, dtype=np.float64), a)
        False

        Contrary to `asanyarray`, ndarray subclasses are not passed through:

        >>> issubclass(np.recarray, np.ndarray)
        True
        >>> a = np.array([(1., 2), (3., 4)], dtype='f4,i4').view(np.recarray)
        >>> np.asarray(a) is a
        False
        >>> np.asanyarray(a) is a
        True

    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', 'A', 'K'}, optional
            Memory layout.  'A' and 'K' depend on the order of input array a.
            'C' row-major (C-style),
            'F' column-major (Fortran-style) memory representation.
            'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
            'K' (keep) preserve input order
            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.
        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
        --------
        >>> import numpy as np

        Convert a list into an array. If all elements are finite, then
        ``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

    ascontiguousarray(...)
        ascontiguousarray(a, dtype=None, *, like=None)

        Return a contiguous array (ndim >= 1) in memory (C order).

        Parameters
        ----------
        a : array_like
            Input array.
        dtype : str or dtype object, optional
            Data-type of returned array.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        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
        --------
        Starting with a Fortran-contiguous array:

        >>> import numpy as np
        >>> x = np.ones((2, 3), order='F')
        >>> x.flags['F_CONTIGUOUS']
        True

        Calling ``ascontiguousarray`` makes a C-contiguous copy:

        >>> y = np.ascontiguousarray(x)
        >>> y.flags['C_CONTIGUOUS']
        True
        >>> np.may_share_memory(x, y)
        False

        Now, starting with a C-contiguous array:

        >>> x = np.ones((2, 3), order='C')
        >>> x.flags['C_CONTIGUOUS']
        True

        Then, calling ``ascontiguousarray`` returns the same object:

        >>> y = np.ascontiguousarray(x)
        >>> x is y
        True

        Note: This function returns an array with at least one-dimension (1-d)
        so it will not preserve 0-d arrays.

    asfortranarray(...)
        asfortranarray(a, dtype=None, *, like=None)

        Return an array (ndim >= 1) laid out in Fortran order in memory.

        Parameters
        ----------
        a : array_like
            Input array.
        dtype : str or dtype object, optional
            By default, the data-type is inferred from the input data.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            The input `a` in Fortran, or column-major, order.

        See Also
        --------
        ascontiguousarray : Convert input to a contiguous (C order) array.
        asanyarray : Convert input to an ndarray with either row or
            column-major memory order.
        require : Return an ndarray that satisfies requirements.
        ndarray.flags : Information about the memory layout of the array.

        Examples
        --------
        Starting with a C-contiguous array:

        >>> import numpy as np
        >>> x = np.ones((2, 3), order='C')
        >>> x.flags['C_CONTIGUOUS']
        True

        Calling ``asfortranarray`` makes a Fortran-contiguous copy:

        >>> y = np.asfortranarray(x)
        >>> y.flags['F_CONTIGUOUS']
        True
        >>> np.may_share_memory(x, y)
        False

        Now, starting with a Fortran-contiguous array:

        >>> x = np.ones((2, 3), order='F')
        >>> x.flags['F_CONTIGUOUS']
        True

        Then, calling ``asfortranarray`` returns the same object:

        >>> y = np.asfortranarray(x)
        >>> x is y
        True

        Note: This function returns an array with at least one-dimension (1-d)
        so it will not preserve 0-d arrays.

    asmatrix(data, dtype=None)
        Interpret the input as a matrix.

        Unlike `matrix`, `asmatrix` does not make a copy if the input is already
        a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.

        Parameters
        ----------
        data : array_like
            Input data.
        dtype : data-type
           Data-type of the output matrix.

        Returns
        -------
        mat : matrix
            `data` interpreted as a matrix.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([[1, 2], [3, 4]])

        >>> m = np.asmatrix(x)

        >>> x[0,0] = 5

        >>> m
        matrix([[5, 2],
                [3, 4]])

    astype(x, dtype, /, *, copy=True, device=None)
        Copies an array to a specified data type.

        This function is an Array API compatible alternative to
        `numpy.ndarray.astype`.

        Parameters
        ----------
        x : ndarray
            Input NumPy array to cast. ``array_likes`` are explicitly not
            supported here.
        dtype : dtype
            Data type of the result.
        copy : bool, optional
            Specifies whether to copy an array when the specified dtype matches
            the data type of the input array ``x``. If ``True``, a newly allocated
            array must always be returned. If ``False`` and the specified dtype
            matches the data type of the input array, the input array must be
            returned; otherwise, a newly allocated array must be returned.
            Defaults to ``True``.
        device : str, optional
            The device on which to place the returned array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.1.0

        Returns
        -------
        out : ndarray
            An array having the specified data type.

        See Also
        --------
        ndarray.astype

        Examples
        --------
        >>> import numpy as np
        >>> arr = np.array([1, 2, 3]); arr
        array([1, 2, 3])
        >>> np.astype(arr, np.float64)
        array([1., 2., 3.])

        Non-copy case:

        >>> arr = np.array([1, 2, 3])
        >>> arr_noncpy = np.astype(arr, arr.dtype, copy=False)
        >>> np.shares_memory(arr, arr_noncpy)
        True

    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 tuple of arrays, each with ``a.ndim >= 1``.
            Copies are made only if necessary.

        See Also
        --------
        atleast_2d, atleast_3d

        Examples
        --------
        >>> import numpy as np
        >>> 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]))

    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 tuple 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
        --------
        >>> import numpy as np
        >>> 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]]))

    atleast_3d(*arys)
        View inputs as arrays with at least three dimensions.

        Parameters
        ----------
        arys1, arys2, ... : array_like
            One or more array-like sequences.  Non-array inputs are converted to
            arrays.  Arrays that already have three or more dimensions are
            preserved.

        Returns
        -------
        res1, res2, ... : ndarray
            An array, or tuple of arrays, each with ``a.ndim >= 3``.  Copies are
            avoided where possible, and views with three or more dimensions are
            returned.  For example, a 1-D array of shape ``(N,)`` becomes a view
            of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
            view of shape ``(M, N, 1)``.

        See Also
        --------
        atleast_1d, atleast_2d

        Examples
        --------
        >>> import numpy as np
        >>> np.atleast_3d(3.0)
        array([[[3.]]])

        >>> x = np.arange(3.0)
        >>> np.atleast_3d(x).shape
        (1, 3, 1)

        >>> x = np.arange(12.0).reshape(4,3)
        >>> np.atleast_3d(x).shape
        (4, 3, 1)
        >>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
        True

        >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
        ...     print(arr, arr.shape) # doctest: +SKIP
        ...
        [[[1]
          [2]]] (1, 2, 1)
        [[[1]
          [2]]] (1, 2, 1)
        [[[1 2]]] (1, 1, 2)

    average(a, axis=None, weights=None, returned=False, *, keepdims=<no value>)
        Compute the weighted average along the specified axis.

        Parameters
        ----------
        a : array_like
            Array containing data to be averaged. If `a` is not an array, a
            conversion is attempted.
        axis : None or int or tuple of ints, optional
            Axis or axes along which to average `a`.  The default,
            `axis=None`, will average over all of the elements of the input array.
            If axis is negative it counts from the last to the first axis.

            .. versionadded:: 1.7.0

            If axis is a tuple of ints, averaging is performed on all of the axes
            specified in the tuple instead of a single axis or all the axes as
            before.
        weights : array_like, optional
            An array of weights associated with the values in `a`. Each value in
            `a` contributes to the average according to its associated weight.
            The array of weights must be the same shape as `a` if no axis is
            specified, otherwise the weights must have dimensions and shape
            consistent with `a` along the specified axis.
            If `weights=None`, then all data in `a` are assumed to have a
            weight equal to one.
            The calculation is::

                avg = sum(a * weights) / sum(weights)

            where the sum is over all included elements.
            The only constraint on the values of `weights` is that `sum(weights)`
            must not be 0.
        returned : bool, optional
            Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
            is returned, otherwise only the average is returned.
            If `weights=None`, `sum_of_weights` is equivalent to the number of
            elements over which the average is taken.
        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 `a`.
            *Note:* `keepdims` will not work with instances of `numpy.matrix`
            or other classes whose methods do not support `keepdims`.

            .. versionadded:: 1.23.0

        Returns
        -------
        retval, [sum_of_weights] : array_type or double
            Return the average along the specified axis. When `returned` is `True`,
            return a tuple with the average as the first element and the sum
            of the weights as the second element. `sum_of_weights` is of the
            same type as `retval`. The result dtype follows a general pattern.
            If `weights` is None, the result dtype will be that of `a` , or ``float64``
            if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
            integral, the result type will be the type of lowest precision capable of
            representing values of both `a` and `weights`. If `a` happens to be
            integral, the previous rules still applies but the result dtype will
            at least be ``float64``.

        Raises
        ------
        ZeroDivisionError
            When all weights along axis are zero. See `numpy.ma.average` for a
            version robust to this type of error.
        TypeError
            When `weights` does not have the same shape as `a`, and `axis=None`.
        ValueError
            When `weights` does not have dimensions and shape consistent with `a`
            along specified `axis`.

        See Also
        --------
        mean

        ma.average : average for masked arrays -- useful if your data contains
                     "missing" values
        numpy.result_type : Returns the type that results from applying the
                            numpy type promotion rules to the arguments.

        Examples
        --------
        >>> import numpy as np
        >>> data = np.arange(1, 5)
        >>> data
        array([1, 2, 3, 4])
        >>> np.average(data)
        2.5
        >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
        4.0

        >>> data = np.arange(6).reshape((3, 2))
        >>> data
        array([[0, 1],
               [2, 3],
               [4, 5]])
        >>> np.average(data, axis=1, weights=[1./4, 3./4])
        array([0.75, 2.75, 4.75])
        >>> np.average(data, weights=[1./4, 3./4])
        Traceback (most recent call last):
            ...
        TypeError: Axis must be specified when shapes of a and weights differ.

        With ``keepdims=True``, the following result has shape (3, 1).

        >>> np.average(data, axis=1, keepdims=True)
        array([[0.5],
               [2.5],
               [4.5]])

        >>> data = np.arange(8).reshape((2, 2, 2))
        >>> data
        array([[[0, 1],
                [2, 3]],
               [[4, 5],
                [6, 7]]])
        >>> np.average(data, axis=(0, 1), weights=[[1./4, 3./4], [1., 1./2]])
        array([3.4, 4.4])
        >>> np.average(data, axis=0, weights=[[1./4, 3./4], [1., 1./2]])
        Traceback (most recent call last):
            ...
        ValueError: Shape of weights must be consistent
        with shape of a along specified axis.

    bartlett(M)
        Return the Bartlett window.

        The Bartlett window is very similar to a triangular window, except
        that the end points are at zero.  It is often used in signal
        processing for tapering a signal, without generating too much
        ripple in the frequency domain.

        Parameters
        ----------
        M : int
            Number of points in the output window. If zero or less, an
            empty array is returned.

        Returns
        -------
        out : array
            The triangular window, with the maximum value normalized to one
            (the value one appears only if the number of samples is odd), with
            the first and last samples equal to zero.

        See Also
        --------
        blackman, hamming, hanning, kaiser

        Notes
        -----
        The Bartlett window is defined as

        .. math:: w(n) = \frac{2}{M-1} \left(
                  \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right|
                  \right)

        Most references to the Bartlett window come from the signal processing
        literature, where it is used as one of many windowing functions for
        smoothing values.  Note that convolution with this window produces linear
        interpolation.  It is also known as an apodization (which means "removing
        the foot", i.e. smoothing discontinuities at the beginning and end of the
        sampled signal) or tapering function. The Fourier transform of the
        Bartlett window is the product of two sinc functions. Note the excellent
        discussion in Kanasewich [2]_.

        References
        ----------
        .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",
               Biometrika 37, 1-16, 1950.
        .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
               The University of Alberta Press, 1975, pp. 109-110.
        .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal
               Processing", Prentice-Hall, 1999, pp. 468-471.
        .. [4] Wikipedia, "Window function",
               https://en.wikipedia.org/wiki/Window_function
        .. [5] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
               "Numerical Recipes", Cambridge University Press, 1986, page 429.

        Examples
        --------
        >>> import numpy as np
        >>> import matplotlib.pyplot as plt
        >>> np.bartlett(12)
        array([ 0.        ,  0.18181818,  0.36363636,  0.54545455,  0.72727273, # may vary
                0.90909091,  0.90909091,  0.72727273,  0.54545455,  0.36363636,
                0.18181818,  0.        ])

        Plot the window and its frequency response (requires SciPy and matplotlib).

        .. plot::
            :include-source:

            import matplotlib.pyplot as plt
            from numpy.fft import fft, fftshift
            window = np.bartlett(51)
            plt.plot(window)
            plt.title("Bartlett window")
            plt.ylabel("Amplitude")
            plt.xlabel("Sample")
            plt.show()
            plt.figure()
            A = fft(window, 2048) / 25.5
            mag = np.abs(fftshift(A))
            freq = np.linspace(-0.5, 0.5, len(A))
            with np.errstate(divide='ignore', invalid='ignore'):
                response = 20 * np.log10(mag)
            response = np.clip(response, -100, 100)
            plt.plot(freq, response)
            plt.title("Frequency response of Bartlett window")
            plt.ylabel("Magnitude [dB]")
            plt.xlabel("Normalized frequency [cycles per sample]")
            plt.axis('tight')
            plt.show()

    base_repr(number, base=2, padding=0)
        Return a string representation of a number in the given base system.

        Parameters
        ----------
        number : int
            The value to convert. Positive and negative values are handled.
        base : int, optional
            Convert `number` to the `base` number system. The valid range is 2-36,
            the default value is 2.
        padding : int, optional
            Number of zeros padded on the left. Default is 0 (no padding).

        Returns
        -------
        out : str
            String representation of `number` in `base` system.

        See Also
        --------
        binary_repr : Faster version of `base_repr` for base 2.

        Examples
        --------
        >>> import numpy as np
        >>> np.base_repr(5)
        '101'
        >>> np.base_repr(6, 5)
        '11'
        >>> np.base_repr(7, base=5, padding=3)
        '00012'

        >>> np.base_repr(10, base=16)
        'A'
        >>> np.base_repr(32, base=16)
        '20'

    binary_repr(num, width=None)
        Return the binary representation of the input number as a string.

        For negative numbers, if width is not given, a minus sign is added to the
        front. If width is given, the two's complement of the number is
        returned, with respect to that width.

        In a two's-complement system negative numbers are represented by the two's
        complement of the absolute value. This is the most common method of
        representing signed integers on computers [1]_. A N-bit two's-complement
        system can represent every integer in the range
        :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

        Parameters
        ----------
        num : int
            Only an integer decimal number can be used.
        width : int, optional
            The length of the returned string if `num` is positive, or the length
            of the two's complement if `num` is negative, provided that `width` is
            at least a sufficient number of bits for `num` to be represented in
            the designated form. If the `width` value is insufficient, an error is
            raised.

        Returns
        -------
        bin : str
            Binary representation of `num` or two's complement of `num`.

        See Also
        --------
        base_repr: Return a string representation of a number in the given base
                   system.
        bin: Python's built-in binary representation generator of an integer.

        Notes
        -----
        `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
        faster.

        References
        ----------
        .. [1] Wikipedia, "Two's complement",
            https://en.wikipedia.org/wiki/Two's_complement

        Examples
        --------
        >>> import numpy as np
        >>> np.binary_repr(3)
        '11'
        >>> np.binary_repr(-3)
        '-11'
        >>> np.binary_repr(3, width=4)
        '0011'

        The two's complement is returned when the input number is negative and
        width is specified:

        >>> np.binary_repr(-3, width=3)
        '101'
        >>> np.binary_repr(-3, width=5)
        '11101'

    bincount(...)
        bincount(x, /, weights=None, minlength=0)

        Count number of occurrences of each value in array of non-negative ints.

        The number of bins (of size 1) is one larger than the largest value in
        `x`. If `minlength` is specified, there will be at least this number
        of bins in the output array (though it will be longer if necessary,
        depending on the contents of `x`).
        Each bin gives the number of occurrences of its index value in `x`.
        If `weights` is specified the input array is weighted by it, i.e. if a
        value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
        of ``out[n] += 1``.

        Parameters
        ----------
        x : array_like, 1 dimension, nonnegative ints
            Input array.
        weights : array_like, optional
            Weights, array of the same shape as `x`.
        minlength : int, optional
            A minimum number of bins for the output array.

            .. versionadded:: 1.6.0

        Returns
        -------
        out : ndarray of ints
            The result of binning the input array.
            The length of `out` is equal to ``np.amax(x)+1``.

        Raises
        ------
        ValueError
            If the input is not 1-dimensional, or contains elements with negative
            values, or if `minlength` is negative.
        TypeError
            If the type of the input is float or complex.

        See Also
        --------
        histogram, digitize, unique

        Examples
        --------
        >>> import numpy as np
        >>> np.bincount(np.arange(5))
        array([1, 1, 1, 1, 1])
        >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))
        array([1, 3, 1, 1, 0, 0, 0, 1])

        >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])
        >>> np.bincount(x).size == np.amax(x)+1
        True

        The input array needs to be of integer dtype, otherwise a
        TypeError is raised:

        >>> np.bincount(np.arange(5, dtype=float))
        Traceback (most recent call last):
          ...
        TypeError: Cannot cast array data from dtype('float64') to dtype('int64')
        according to the rule 'safe'

        A possible use of ``bincount`` is to perform sums over
        variable-size chunks of an array, using the ``weights`` keyword.

        >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
        >>> x = np.array([0, 1, 1, 2, 2, 2])
        >>> np.bincount(x,  weights=w)
        array([ 0.3,  0.7,  1.1])

    blackman(M)
        Return the Blackman window.

        The Blackman window is a taper formed by using the first three
        terms of a summation of cosines. It was designed to have close to the
        minimal leakage possible.  It is close to optimal, only slightly worse
        than a Kaiser window.

        Parameters
        ----------
        M : int
            Number of points in the output window. If zero or less, an empty
            array is returned.

        Returns
        -------
        out : ndarray
            The window, with the maximum value normalized to one (the value one
            appears only if the number of samples is odd).

        See Also
        --------
        bartlett, hamming, hanning, kaiser

        Notes
        -----
        The Blackman window is defined as

        .. math::  w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M)

        Most references to the Blackman window come from the signal processing
        literature, where it is used as one of many windowing functions for
        smoothing values.  It is also known as an apodization (which means
        "removing the foot", i.e. smoothing discontinuities at the beginning
        and end of the sampled signal) or tapering function. It is known as a
        "near optimal" tapering function, almost as good (by some measures)
        as the kaiser window.

        References
        ----------
        Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,
        Dover Publications, New York.

        Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.
        Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.

        Examples
        --------
        >>> import numpy as np
        >>> import matplotlib.pyplot as plt
        >>> np.blackman(12)
        array([-1.38777878e-17,   3.26064346e-02,   1.59903635e-01, # may vary
                4.14397981e-01,   7.36045180e-01,   9.67046769e-01,
                9.67046769e-01,   7.36045180e-01,   4.14397981e-01,
                1.59903635e-01,   3.26064346e-02,  -1.38777878e-17])

        Plot the window and the frequency response.

        .. plot::
            :include-source:

            import matplotlib.pyplot as plt
            from numpy.fft import fft, fftshift
            window = np.blackman(51)
            plt.plot(window)
            plt.title("Blackman window")
            plt.ylabel("Amplitude")
            plt.xlabel("Sample")
            plt.show()  # doctest: +SKIP

            plt.figure()
            A = fft(window, 2048) / 25.5
            mag = np.abs(fftshift(A))
            freq = np.linspace(-0.5, 0.5, len(A))
            with np.errstate(divide='ignore', invalid='ignore'):
                response = 20 * np.log10(mag)
            response = np.clip(response, -100, 100)
            plt.plot(freq, response)
            plt.title("Frequency response of Blackman window")
            plt.ylabel("Magnitude [dB]")
            plt.xlabel("Normalized frequency [cycles per sample]")
            plt.axis('tight')
            plt.show()

    block(arrays)
        Assemble an nd-array from nested lists of blocks.

        Blocks in the innermost lists are concatenated (see `concatenate`) along
        the last dimension (-1), then these are concatenated along the
        second-last dimension (-2), and so on until the outermost list is reached.

        Blocks can be of any dimension, but will not be broadcasted using
        the normal rules. Instead, leading axes of size 1 are inserted,
        to make ``block.ndim`` the same for all blocks. This is primarily useful
        for working with scalars, and means that code like ``np.block([v, 1])``
        is valid, where ``v.ndim == 1``.

        When the nested list is two levels deep, this allows block matrices to be
        constructed from their components.

        .. versionadded:: 1.13.0

        Parameters
        ----------
        arrays : nested list of array_like or scalars (but not tuples)
            If passed a single ndarray or scalar (a nested list of depth 0), this
            is returned unmodified (and not copied).

            Elements shapes must match along the appropriate axes (without
            broadcasting), but leading 1s will be prepended to the shape as
            necessary to make the dimensions match.

        Returns
        -------
        block_array : ndarray
            The array assembled from the given blocks.

            The dimensionality of the output is equal to the greatest of:

            * the dimensionality of all the inputs
            * the depth to which the input list is nested

        Raises
        ------
        ValueError
            * If list depths are mismatched - for instance, ``[[a, b], c]`` is
              illegal, and should be spelt ``[[a, b], [c]]``
            * If lists are empty - for instance, ``[[a, b], []]``

        See Also
        --------
        concatenate : Join a sequence of arrays along an existing axis.
        stack : Join a sequence of arrays along a new axis.
        vstack : Stack arrays in sequence vertically (row wise).
        hstack : Stack arrays in sequence horizontally (column wise).
        dstack : Stack arrays in sequence depth wise (along third axis).
        column_stack : Stack 1-D arrays as columns into a 2-D array.
        vsplit : Split an array into multiple sub-arrays vertically (row-wise).
        unstack : Split an array into a tuple of sub-arrays along an axis.

        Notes
        -----

        When called with only scalars, ``np.block`` is equivalent to an ndarray
        call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
        ``np.array([[1, 2], [3, 4]])``.

        This function does not enforce that the blocks lie on a fixed grid.
        ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::

            AAAbb
            AAAbb
            cccDD

        But is also allowed to produce, for some ``a, b, c, d``::

            AAAbb
            AAAbb
            cDDDD

        Since concatenation happens along the last axis first, `block` is *not*
        capable of producing the following directly::

            AAAbb
            cccbb
            cccDD

        Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is
        equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.

        Examples
        --------
        The most common use of this function is to build a block matrix:

        >>> import numpy as np
        >>> A = np.eye(2) * 2
        >>> B = np.eye(3) * 3
        >>> np.block([
        ...     [A,               np.zeros((2, 3))],
        ...     [np.ones((3, 2)), B               ]
        ... ])
        array([[2., 0., 0., 0., 0.],
               [0., 2., 0., 0., 0.],
               [1., 1., 3., 0., 0.],
               [1., 1., 0., 3., 0.],
               [1., 1., 0., 0., 3.]])

        With a list of depth 1, `block` can be used as `hstack`:

        >>> np.block([1, 2, 3])              # hstack([1, 2, 3])
        array([1, 2, 3])

        >>> a = np.array([1, 2, 3])
        >>> b = np.array([4, 5, 6])
        >>> np.block([a, b, 10])             # hstack([a, b, 10])
        array([ 1,  2,  3,  4,  5,  6, 10])

        >>> A = np.ones((2, 2), int)
        >>> B = 2 * A
        >>> np.block([A, B])                 # hstack([A, B])
        array([[1, 1, 2, 2],
               [1, 1, 2, 2]])

        With a list of depth 2, `block` can be used in place of `vstack`:

        >>> a = np.array([1, 2, 3])
        >>> b = np.array([4, 5, 6])
        >>> np.block([[a], [b]])             # vstack([a, b])
        array([[1, 2, 3],
               [4, 5, 6]])

        >>> A = np.ones((2, 2), int)
        >>> B = 2 * A
        >>> np.block([[A], [B]])             # vstack([A, B])
        array([[1, 1],
               [1, 1],
               [2, 2],
               [2, 2]])

        It can also be used in place of `atleast_1d` and `atleast_2d`:

        >>> a = np.array(0)
        >>> b = np.array([1])
        >>> np.block([a])                    # atleast_1d(a)
        array([0])
        >>> np.block([b])                    # atleast_1d(b)
        array([1])

        >>> np.block([[a]])                  # atleast_2d(a)
        array([[0]])
        >>> np.block([[b]])                  # atleast_2d(b)
        array([[1]])

    bmat(obj, ldict=None, gdict=None)
        Build a matrix object from a string, nested sequence, or array.

        Parameters
        ----------
        obj : str or array_like
            Input data. If a string, variables in the current scope may be
            referenced by name.
        ldict : dict, optional
            A dictionary that replaces local operands in current frame.
            Ignored if `obj` is not a string or `gdict` is None.
        gdict : dict, optional
            A dictionary that replaces global operands in current frame.
            Ignored if `obj` is not a string.

        Returns
        -------
        out : matrix
            Returns a matrix object, which is a specialized 2-D array.

        See Also
        --------
        block :
            A generalization of this function for N-d arrays, that returns normal
            ndarrays.

        Examples
        --------
        >>> import numpy as np
        >>> A = np.asmatrix('1 1; 1 1')
        >>> B = np.asmatrix('2 2; 2 2')
        >>> C = np.asmatrix('3 4; 5 6')
        >>> D = np.asmatrix('7 8; 9 0')

        All the following expressions construct the same block matrix:

        >>> np.bmat([[A, B], [C, D]])
        matrix([[1, 1, 2, 2],
                [1, 1, 2, 2],
                [3, 4, 7, 8],
                [5, 6, 9, 0]])
        >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
        matrix([[1, 1, 2, 2],
                [1, 1, 2, 2],
                [3, 4, 7, 8],
                [5, 6, 9, 0]])
        >>> np.bmat('A,B; C,D')
        matrix([[1, 1, 2, 2],
                [1, 1, 2, 2],
                [3, 4, 7, 8],
                [5, 6, 9, 0]])

    broadcast_arrays(*args, subok=False)
        Broadcast any number of arrays against each other.

        Parameters
        ----------
        *args : array_likes
            The arrays to broadcast.

        subok : bool, optional
            If True, then sub-classes will be passed-through, otherwise
            the returned arrays will be forced to be a base-class array (default).

        Returns
        -------
        broadcasted : tuple of arrays
            These arrays are views on the original arrays.  They are typically
            not contiguous.  Furthermore, more than one element of a
            broadcasted array may refer to a single memory location. If you need
            to write to the arrays, make copies first. While you can set the
            ``writable`` flag True, writing to a single output value may end up
            changing more than one location in the output array.

            .. deprecated:: 1.17
                The output is currently marked so that if written to, a deprecation
                warning will be emitted. A future version will set the
                ``writable`` flag False so writing to it will raise an error.

        See Also
        --------
        broadcast
        broadcast_to
        broadcast_shapes

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([[1,2,3]])
        >>> y = np.array([[4],[5]])
        >>> np.broadcast_arrays(x, y)
        (array([[1, 2, 3],
                [1, 2, 3]]),
         array([[4, 4, 4],
                [5, 5, 5]]))

        Here is a useful idiom for getting contiguous copies instead of
        non-contiguous views.

        >>> [np.array(a) for a in np.broadcast_arrays(x, y)]
        [array([[1, 2, 3],
                [1, 2, 3]]),
         array([[4, 4, 4],
                [5, 5, 5]])]

    broadcast_shapes(*args)
        Broadcast the input shapes into a single shape.

        :ref:`Learn more about broadcasting here <basics.broadcasting>`.

        .. versionadded:: 1.20.0

        Parameters
        ----------
        *args : tuples of ints, or ints
            The shapes to be broadcast against each other.

        Returns
        -------
        tuple
            Broadcasted shape.

        Raises
        ------
        ValueError
            If the shapes are not compatible and cannot be broadcast according
            to NumPy's broadcasting rules.

        See Also
        --------
        broadcast
        broadcast_arrays
        broadcast_to

        Examples
        --------
        >>> import numpy as np
        >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
        (3, 2)

        >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))
        (5, 6, 7)

    broadcast_to(array, shape, subok=False)
        Broadcast an array to a new shape.

        Parameters
        ----------
        array : array_like
            The array to broadcast.
        shape : tuple or int
            The shape of the desired array. A single integer ``i`` is interpreted
            as ``(i,)``.
        subok : bool, optional
            If True, then sub-classes will be passed-through, otherwise
            the returned array will be forced to be a base-class array (default).

        Returns
        -------
        broadcast : array
            A readonly view on the original array with the given shape. It is
            typically not contiguous. Furthermore, more than one element of a
            broadcasted array may refer to a single memory location.

        Raises
        ------
        ValueError
            If the array is not compatible with the new shape according to NumPy's
            broadcasting rules.

        See Also
        --------
        broadcast
        broadcast_arrays
        broadcast_shapes

        Notes
        -----
        .. versionadded:: 1.10.0

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([1, 2, 3])
        >>> np.broadcast_to(x, (3, 3))
        array([[1, 2, 3],
               [1, 2, 3],
               [1, 2, 3]])

    busday_count(...)
        busday_count(
            begindates,
            enddates,
            weekmask='1111100',
            holidays=[],
            busdaycal=None,
            out=None
        )

        Counts the number of valid days between `begindates` and
        `enddates`, not including the day of `enddates`.

        If ``enddates`` specifies a date value that is earlier than the
        corresponding ``begindates`` date value, the count will be negative.

        .. versionadded:: 1.7.0

        Parameters
        ----------
        begindates : array_like of datetime64[D]
            The array of the first dates for counting.
        enddates : array_like of datetime64[D]
            The array of the end dates for counting, which are excluded
            from the count themselves.
        weekmask : str or array_like of bool, optional
            A seven-element array indicating which of Monday through Sunday are
            valid days. May be specified as a length-seven list or array, like
            [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
            like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
            weekdays, optionally separated by white space. Valid abbreviations
            are: Mon Tue Wed Thu Fri Sat Sun
        holidays : array_like of datetime64[D], optional
            An array of dates to consider as invalid dates.  They may be
            specified in any order, and NaT (not-a-time) dates are ignored.
            This list is saved in a normalized form that is suited for
            fast calculations of valid days.
        busdaycal : busdaycalendar, optional
            A `busdaycalendar` object which specifies the valid days. If this
            parameter is provided, neither weekmask nor holidays may be
            provided.
        out : array of int, optional
            If provided, this array is filled with the result.

        Returns
        -------
        out : array of int
            An array with a shape from broadcasting ``begindates`` and ``enddates``
            together, containing the number of valid days between
            the begin and end dates.

        See Also
        --------
        busdaycalendar : An object that specifies a custom set of valid days.
        is_busday : Returns a boolean array indicating valid days.
        busday_offset : Applies an offset counted in valid days.

        Examples
        --------
        >>> import numpy as np
        >>> # Number of weekdays in January 2011
        ... np.busday_count('2011-01', '2011-02')
        21
        >>> # Number of weekdays in 2011
        >>> np.busday_count('2011', '2012')
        260
        >>> # Number of Saturdays in 2011
        ... np.busday_count('2011', '2012', weekmask='Sat')
        53

    busday_offset(...)
        busday_offset(
            dates,
            offsets,
            roll='raise',
            weekmask='1111100',
            holidays=None,
            busdaycal=None,
            out=None
        )

        First adjusts the date to fall on a valid day according to
        the ``roll`` rule, then applies offsets to the given dates
        counted in valid days.

        .. versionadded:: 1.7.0

        Parameters
        ----------
        dates : array_like of datetime64[D]
            The array of dates to process.
        offsets : array_like of int
            The array of offsets, which is broadcast with ``dates``.
        roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding',         'modifiedfollowing', 'modifiedpreceding'}, optional
            How to treat dates that do not fall on a valid day. The default
            is 'raise'.

            * 'raise' means to raise an exception for an invalid day.
            * 'nat' means to return a NaT (not-a-time) for an invalid day.
            * 'forward' and 'following' mean to take the first valid day
              later in time.
            * 'backward' and 'preceding' mean to take the first valid day
              earlier in time.
            * 'modifiedfollowing' means to take the first valid day
              later in time unless it is across a Month boundary, in which
              case to take the first valid day earlier in time.
            * 'modifiedpreceding' means to take the first valid day
              earlier in time unless it is across a Month boundary, in which
              case to take the first valid day later in time.
        weekmask : str or array_like of bool, optional
            A seven-element array indicating which of Monday through Sunday are
            valid days. May be specified as a length-seven list or array, like
            [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
            like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
            weekdays, optionally separated by white space. Valid abbreviations
            are: Mon Tue Wed Thu Fri Sat Sun
        holidays : array_like of datetime64[D], optional
            An array of dates to consider as invalid dates.  They may be
            specified in any order, and NaT (not-a-time) dates are ignored.
            This list is saved in a normalized form that is suited for
            fast calculations of valid days.
        busdaycal : busdaycalendar, optional
            A `busdaycalendar` object which specifies the valid days. If this
            parameter is provided, neither weekmask nor holidays may be
            provided.
        out : array of datetime64[D], optional
            If provided, this array is filled with the result.

        Returns
        -------
        out : array of datetime64[D]
            An array with a shape from broadcasting ``dates`` and ``offsets``
            together, containing the dates with offsets applied.

        See Also
        --------
        busdaycalendar : An object that specifies a custom set of valid days.
        is_busday : Returns a boolean array indicating valid days.
        busday_count : Counts how many valid days are in a half-open date range.

        Examples
        --------
        >>> import numpy as np
        >>> # First business day in October 2011 (not accounting for holidays)
        ... np.busday_offset('2011-10', 0, roll='forward')
        np.datetime64('2011-10-03')
        >>> # Last business day in February 2012 (not accounting for holidays)
        ... np.busday_offset('2012-03', -1, roll='forward')
        np.datetime64('2012-02-29')
        >>> # Third Wednesday in January 2011
        ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')
        np.datetime64('2011-01-19')
        >>> # 2012 Mother's Day in Canada and the U.S.
        ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
        np.datetime64('2012-05-13')

        >>> # First business day on or after a date
        ... np.busday_offset('2011-03-20', 0, roll='forward')
        np.datetime64('2011-03-21')
        >>> np.busday_offset('2011-03-22', 0, roll='forward')
        np.datetime64('2011-03-22')
        >>> # First business day after a date
        ... np.busday_offset('2011-03-20', 1, roll='backward')
        np.datetime64('2011-03-21')
        >>> np.busday_offset('2011-03-22', 1, roll='backward')
        np.datetime64('2011-03-23')

    can_cast(...)
        can_cast(from_, to, casting='safe')

        Returns True if cast between data types can occur according to the
        casting rule.

        Parameters
        ----------
        from_ : dtype, dtype specifier, NumPy scalar, or array
            Data type, NumPy scalar, or array to cast from.
        to : dtype or dtype specifier
            Data type to cast to.
        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur.

            * '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.

        Returns
        -------
        out : bool
            True if cast can occur according to the casting rule.

        Notes
        -----
        .. versionchanged:: 1.17.0
           Casting between a simple data type and a structured one is possible only
           for "unsafe" casting.  Casting to multiple fields is allowed, but
           casting from multiple fields is not.

        .. versionchanged:: 1.9.0
           Casting from numeric to string types in 'safe' casting mode requires
           that the string dtype length is long enough to store the maximum
           integer/float value converted.

        .. versionchanged:: 2.0
           This function does not support Python scalars anymore and does not
           apply any value-based logic for 0-D arrays and NumPy scalars.

        See also
        --------
        dtype, result_type

        Examples
        --------
        Basic examples

        >>> import numpy as np
        >>> np.can_cast(np.int32, np.int64)
        True
        >>> np.can_cast(np.float64, complex)
        True
        >>> np.can_cast(complex, float)
        False

        >>> np.can_cast('i8', 'f8')
        True
        >>> np.can_cast('i8', 'f4')
        False
        >>> np.can_cast('i4', 'S4')
        False

    choose(a, choices, out=None, mode='raise')
        Construct an array from an index array and a list of arrays to choose from.

        First of all, if confused or uncertain, definitely look at the Examples -
        in its full generality, this function is less simple than it might
        seem from the following code description (below ndi =
        `numpy.lib.index_tricks`):

        ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.

        But this omits some subtleties.  Here is a fully general summary:

        Given an "index" array (`a`) of integers and a sequence of ``n`` arrays
        (`choices`), `a` and each choice array are first broadcast, as necessary,
        to arrays of a common shape; calling these *Ba* and *Bchoices[i], i =
        0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``
        for each ``i``.  Then, a new array with shape ``Ba.shape`` is created as
        follows:

        * if ``mode='raise'`` (the default), then, first of all, each element of
          ``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose
          that ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)``
          position in ``Ba`` - then the value at the same position in the new array
          is the value in ``Bchoices[i]`` at that same position;

        * if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed)
          integer; modular arithmetic is used to map integers outside the range
          `[0, n-1]` back into that range; and then the new array is constructed
          as above;

        * if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed)
          integer; negative integers are mapped to 0; values greater than ``n-1``
          are mapped to ``n-1``; and then the new array is constructed as above.

        Parameters
        ----------
        a : int array
            This array must contain integers in ``[0, n-1]``, where ``n`` is the
            number of choices, unless ``mode=wrap`` or ``mode=clip``, in which
            cases any integers are permissible.
        choices : sequence of arrays
            Choice arrays. `a` and all of the choices must be broadcastable to the
            same shape.  If `choices` is itself an array (not recommended), then
            its outermost dimension (i.e., the one corresponding to
            ``choices.shape[0]``) is taken as defining the "sequence".
        out : array, optional
            If provided, the result will be inserted into this array. It should
            be of the appropriate shape and dtype. Note that `out` is always
            buffered if ``mode='raise'``; use other modes for better performance.
        mode : {'raise' (default), 'wrap', 'clip'}, optional
            Specifies how indices outside ``[0, n-1]`` will be treated:

            * 'raise' : an exception is raised
            * 'wrap' : value becomes value mod ``n``
            * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1

        Returns
        -------
        merged_array : array
            The merged result.

        Raises
        ------
        ValueError: shape mismatch
            If `a` and each choice array are not all broadcastable to the same
            shape.

        See Also
        --------
        ndarray.choose : equivalent method
        numpy.take_along_axis : Preferable if `choices` is an array

        Notes
        -----
        To reduce the chance of misinterpretation, even though the following
        "abuse" is nominally supported, `choices` should neither be, nor be
        thought of as, a single array, i.e., the outermost sequence-like container
        should be either a list or a tuple.

        Examples
        --------

        >>> import numpy as np
        >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
        ...   [20, 21, 22, 23], [30, 31, 32, 33]]
        >>> np.choose([2, 3, 1, 0], choices
        ... # the first element of the result will be the first element of the
        ... # third (2+1) "array" in choices, namely, 20; the second element
        ... # will be the second element of the fourth (3+1) choice array, i.e.,
        ... # 31, etc.
        ... )
        array([20, 31, 12,  3])
        >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
        array([20, 31, 12,  3])
        >>> # because there are 4 choice arrays
        >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
        array([20,  1, 12,  3])
        >>> # i.e., 0

        A couple examples illustrating how choose broadcasts:

        >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
        >>> choices = [-10, 10]
        >>> np.choose(a, choices)
        array([[ 10, -10,  10],
               [-10,  10, -10],
               [ 10, -10,  10]])

        >>> # With thanks to Anne Archibald
        >>> a = np.array([0, 1]).reshape((2,1,1))
        >>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
        >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
        >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
        array([[[ 1,  1,  1,  1,  1],
                [ 2,  2,  2,  2,  2],
                [ 3,  3,  3,  3,  3]],
               [[-1, -2, -3, -4, -5],
                [-1, -2, -3, -4, -5],
                [-1, -2, -3, -4, -5]]])

    clip(a, a_min=<no value>, a_max=<no value>, out=None, *, min=<no value>, max=<no value>, **kwargs)
        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.

        Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``.

        No check is performed to ensure ``a_min < a_max``.

        Parameters
        ----------
        a : array_like
            Array containing elements to clip.
        a_min, a_max : array_like or None
            Minimum and maximum value. If ``None``, clipping is not performed on
            the corresponding edge. If both ``a_min`` and ``a_max`` are ``None``,
            the elements of the returned array stay the same. Both are broadcasted
            against ``a``.
        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.
        min, max : array_like or None
            Array API compatible alternatives for ``a_min`` and ``a_max``
            arguments. Either ``a_min`` and ``a_max`` or ``min`` and ``max``
            can be passed at the same time. Default: ``None``.

            .. versionadded:: 2.1.0
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

            .. versionadded:: 1.17.0

        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
        --------
        :ref:`ufuncs-output-type`

        Notes
        -----
        When `a_min` is greater than `a_max`, `clip` returns an
        array in which all values are equal to `a_max`,
        as shown in the second example.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(10)
        >>> a
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        >>> np.clip(a, 1, 8)
        array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
        >>> np.clip(a, 8, 1)
        array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
        >>> np.clip(a, 3, 6, out=a)
        array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
        >>> 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])

    column_stack(tup)
        Stack 1-D arrays as columns into a 2-D array.

        Take a sequence of 1-D arrays and stack them as columns
        to make a single 2-D array. 2-D arrays are stacked as-is,
        just like with `hstack`.  1-D arrays are turned into 2-D columns
        first.

        Parameters
        ----------
        tup : sequence of 1-D or 2-D arrays.
            Arrays to stack. All of them must have the same first dimension.

        Returns
        -------
        stacked : 2-D array
            The array formed by stacking the given arrays.

        See Also
        --------
        stack, hstack, vstack, concatenate

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array((1,2,3))
        >>> b = np.array((2,3,4))
        >>> np.column_stack((a,b))
        array([[1, 2],
               [2, 3],
               [3, 4]])

    common_type(*arrays)
        Return a scalar type which is common to the input arrays.

        The return type will always be an inexact (i.e. floating point) scalar
        type, even if all the arrays are integer arrays. If one of the inputs is
        an integer array, the minimum precision type that is returned is a
        64-bit floating point dtype.

        All input arrays except int64 and uint64 can be safely cast to the
        returned dtype without loss of information.

        Parameters
        ----------
        array1, array2, ... : ndarrays
            Input arrays.

        Returns
        -------
        out : data type code
            Data type code.

        See Also
        --------
        dtype, mintypecode

        Examples
        --------
        >>> np.common_type(np.arange(2, dtype=np.float32))
        <class 'numpy.float32'>
        >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
        <class 'numpy.float64'>
        >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
        <class 'numpy.complex128'>

    compress(condition, a, axis=None, out=None)
        Return selected slices of an array along given axis.

        When working along a given axis, a slice along that axis is returned in
        `output` for each index where `condition` evaluates to True. When
        working on a 1-D array, `compress` is equivalent to `extract`.

        Parameters
        ----------
        condition : 1-D array of bools
            Array that selects which entries to return. If len(condition)
            is less than the size of `a` along the given axis, then output is
            truncated to the length of the condition array.
        a : array_like
            Array from which to extract a part.
        axis : int, optional
            Axis along which to take slices. If None (default), work on the
            flattened array.
        out : ndarray, optional
            Output array.  Its type is preserved and it must be of the right
            shape to hold the output.

        Returns
        -------
        compressed_array : ndarray
            A copy of `a` without the slices along axis for which `condition`
            is false.

        See Also
        --------
        take, choose, diag, diagonal, select
        ndarray.compress : Equivalent method in ndarray
        extract : Equivalent method when working on 1-D arrays
        :ref:`ufuncs-output-type`

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4], [5, 6]])
        >>> a
        array([[1, 2],
               [3, 4],
               [5, 6]])
        >>> np.compress([0, 1], a, axis=0)
        array([[3, 4]])
        >>> np.compress([False, True, True], a, axis=0)
        array([[3, 4],
               [5, 6]])
        >>> np.compress([False, True], a, axis=1)
        array([[2],
               [4],
               [6]])

        Working on the flattened array does not return slices along an axis but
        selects elements.

        >>> np.compress([False, True], a)
        array([2])

    concat = concatenate(...)
        concatenate(
            (a1, a2, ...),
            axis=0,
            out=None,
            dtype=None,
            casting="same_kind"
        )

        Join a sequence of arrays along an existing axis.

        Parameters
        ----------
        a1, a2, ... : sequence of array_like
            The arrays must have the same shape, except in the dimension
            corresponding to `axis` (the first, by default).
        axis : int, optional
            The axis along which the arrays will be joined.  If axis is None,
            arrays are flattened before use.  Default is 0.
        out : ndarray, optional
            If provided, the destination to place the result. The shape must be
            correct, matching that of what concatenate would have returned if no
            out argument were specified.
        dtype : str or dtype
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`.

            .. versionadded:: 1.20.0

        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur. Defaults to 'same_kind'.
            For a description of the options, please see :term:`casting`.

            .. versionadded:: 1.20.0

        Returns
        -------
        res : ndarray
            The concatenated array.

        See Also
        --------
        ma.concatenate : Concatenate function that preserves input masks.
        array_split : Split an array into multiple sub-arrays of equal or
                      near-equal size.
        split : Split array into a list of multiple sub-arrays of equal size.
        hsplit : Split array into multiple sub-arrays horizontally (column wise).
        vsplit : Split array into multiple sub-arrays vertically (row wise).
        dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
        stack : Stack a sequence of arrays along a new axis.
        block : Assemble arrays from blocks.
        hstack : Stack arrays in sequence horizontally (column wise).
        vstack : Stack arrays in sequence vertically (row wise).
        dstack : Stack arrays in sequence depth wise (along third dimension).
        column_stack : Stack 1-D arrays as columns into a 2-D array.

        Notes
        -----
        When one or more of the arrays to be concatenated is a MaskedArray,
        this function will return a MaskedArray object instead of an ndarray,
        but the input masks are *not* preserved. In cases where a MaskedArray
        is expected as input, use the ma.concatenate function from the masked
        array module instead.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> b = np.array([[5, 6]])
        >>> np.concatenate((a, b), axis=0)
        array([[1, 2],
               [3, 4],
               [5, 6]])
        >>> np.concatenate((a, b.T), axis=1)
        array([[1, 2, 5],
               [3, 4, 6]])
        >>> np.concatenate((a, b), axis=None)
        array([1, 2, 3, 4, 5, 6])

        This function will not preserve masking of MaskedArray inputs.

        >>> a = np.ma.arange(3)
        >>> a[1] = np.ma.masked
        >>> b = np.arange(2, 5)
        >>> a
        masked_array(data=[0, --, 2],
                     mask=[False,  True, False],
               fill_value=999999)
        >>> b
        array([2, 3, 4])
        >>> np.concatenate([a, b])
        masked_array(data=[0, 1, 2, 2, 3, 4],
                     mask=False,
               fill_value=999999)
        >>> np.ma.concatenate([a, b])
        masked_array(data=[0, --, 2, 2, 3, 4],
                     mask=[False,  True, False, False, False, False],
               fill_value=999999)

    concatenate(...)
        concatenate(
            (a1, a2, ...),
            axis=0,
            out=None,
            dtype=None,
            casting="same_kind"
        )

        Join a sequence of arrays along an existing axis.

        Parameters
        ----------
        a1, a2, ... : sequence of array_like
            The arrays must have the same shape, except in the dimension
            corresponding to `axis` (the first, by default).
        axis : int, optional
            The axis along which the arrays will be joined.  If axis is None,
            arrays are flattened before use.  Default is 0.
        out : ndarray, optional
            If provided, the destination to place the result. The shape must be
            correct, matching that of what concatenate would have returned if no
            out argument were specified.
        dtype : str or dtype
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`.

            .. versionadded:: 1.20.0

        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur. Defaults to 'same_kind'.
            For a description of the options, please see :term:`casting`.

            .. versionadded:: 1.20.0

        Returns
        -------
        res : ndarray
            The concatenated array.

        See Also
        --------
        ma.concatenate : Concatenate function that preserves input masks.
        array_split : Split an array into multiple sub-arrays of equal or
                      near-equal size.
        split : Split array into a list of multiple sub-arrays of equal size.
        hsplit : Split array into multiple sub-arrays horizontally (column wise).
        vsplit : Split array into multiple sub-arrays vertically (row wise).
        dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
        stack : Stack a sequence of arrays along a new axis.
        block : Assemble arrays from blocks.
        hstack : Stack arrays in sequence horizontally (column wise).
        vstack : Stack arrays in sequence vertically (row wise).
        dstack : Stack arrays in sequence depth wise (along third dimension).
        column_stack : Stack 1-D arrays as columns into a 2-D array.

        Notes
        -----
        When one or more of the arrays to be concatenated is a MaskedArray,
        this function will return a MaskedArray object instead of an ndarray,
        but the input masks are *not* preserved. In cases where a MaskedArray
        is expected as input, use the ma.concatenate function from the masked
        array module instead.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> b = np.array([[5, 6]])
        >>> np.concatenate((a, b), axis=0)
        array([[1, 2],
               [3, 4],
               [5, 6]])
        >>> np.concatenate((a, b.T), axis=1)
        array([[1, 2, 5],
               [3, 4, 6]])
        >>> np.concatenate((a, b), axis=None)
        array([1, 2, 3, 4, 5, 6])

        This function will not preserve masking of MaskedArray inputs.

        >>> a = np.ma.arange(3)
        >>> a[1] = np.ma.masked
        >>> b = np.arange(2, 5)
        >>> a
        masked_array(data=[0, --, 2],
                     mask=[False,  True, False],
               fill_value=999999)
        >>> b
        array([2, 3, 4])
        >>> np.concatenate([a, b])
        masked_array(data=[0, 1, 2, 2, 3, 4],
                     mask=False,
               fill_value=999999)
        >>> np.ma.concatenate([a, b])
        masked_array(data=[0, --, 2, 2, 3, 4],
                     mask=[False,  True, False, False, False, False],
               fill_value=999999)

    convolve(a, v, mode='full')
        Returns the discrete, linear convolution of two one-dimensional sequences.

        The convolution operator is often seen in signal processing, where it
        models the effect of a linear time-invariant system on a signal [1]_.  In
        probability theory, the sum of two independent random variables is
        distributed according to the convolution of their individual
        distributions.

        If `v` is longer than `a`, the arrays are swapped before computation.

        Parameters
        ----------
        a : (N,) array_like
            First one-dimensional input array.
        v : (M,) array_like
            Second one-dimensional input array.
        mode : {'full', 'valid', 'same'}, optional
            'full':
              By default, mode is 'full'.  This returns the convolution
              at each point of overlap, with an output shape of (N+M-1,). At
              the end-points of the convolution, the signals do not overlap
              completely, and boundary effects may be seen.

            'same':
              Mode 'same' returns output of length ``max(M, N)``.  Boundary
              effects are still visible.

            'valid':
              Mode 'valid' returns output of length
              ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
              for points where the signals overlap completely.  Values outside
              the signal boundary have no effect.

        Returns
        -------
        out : ndarray
            Discrete, linear convolution of `a` and `v`.

        See Also
        --------
        scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
                                   Transform.
        scipy.linalg.toeplitz : Used to construct the convolution operator.
        polymul : Polynomial multiplication. Same output as convolve, but also
                  accepts poly1d objects as input.

        Notes
        -----
        The discrete convolution operation is defined as

        .. math:: (a * v)_n = \sum_{m = -\infty}^{\infty} a_m v_{n - m}

        It can be shown that a convolution :math:`x(t) * y(t)` in time/space
        is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
        domain, after appropriate padding (padding is necessary to prevent
        circular convolution).  Since multiplication is more efficient (faster)
        than convolution, the function `scipy.signal.fftconvolve` exploits the
        FFT to calculate the convolution of large data-sets.

        References
        ----------
        .. [1] Wikipedia, "Convolution",
            https://en.wikipedia.org/wiki/Convolution

        Examples
        --------
        Note how the convolution operator flips the second array
        before "sliding" the two across one another:

        >>> import numpy as np
        >>> np.convolve([1, 2, 3], [0, 1, 0.5])
        array([0. , 1. , 2.5, 4. , 1.5])

        Only return the middle values of the convolution.
        Contains boundary effects, where zeros are taken
        into account:

        >>> np.convolve([1,2,3],[0,1,0.5], 'same')
        array([1. ,  2.5,  4. ])

        The two arrays are of the same length, so there
        is only one position where they completely overlap:

        >>> np.convolve([1,2,3],[0,1,0.5], 'valid')
        array([2.5])

    copy(a, order='K', subok=False)
        Return an array copy of the given object.

        Parameters
        ----------
        a : array_like
            Input data.
        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 :meth:`ndarray.copy` are very
            similar, but have different default values for their order=
            arguments.)
        subok : bool, optional
            If True, then sub-classes will be passed-through, otherwise the
            returned array will be forced to be a base-class array (defaults to False).

            .. versionadded:: 1.19.0

        Returns
        -------
        arr : ndarray
            Array interpretation of `a`.

        See Also
        --------
        ndarray.copy : Preferred method for creating an array copy

        Notes
        -----
        This is equivalent to:

        >>> np.array(a, copy=True)  #doctest: +SKIP

        The copy made of the data is shallow, i.e., for arrays with object dtype,
        the new array will point to the same objects.
        See Examples from `ndarray.copy`.

        Examples
        --------
        >>> import numpy as np

        Create an array x, with a reference y and a copy z:

        >>> x = np.array([1, 2, 3])
        >>> y = x
        >>> z = np.copy(x)

        Note that, when we modify x, y changes, but not z:

        >>> x[0] = 10
        >>> x[0] == y[0]
        True
        >>> x[0] == z[0]
        False

        Note that, np.copy clears previously set WRITEABLE=False flag.

        >>> a = np.array([1, 2, 3])
        >>> a.flags["WRITEABLE"] = False
        >>> b = np.copy(a)
        >>> b.flags["WRITEABLE"]
        True
        >>> b[0] = 3
        >>> b
        array([3, 2, 3])

    copyto(...)
        copyto(dst, src, casting='same_kind', where=True)

        Copies values from one array to another, broadcasting as necessary.

        Raises a TypeError if the `casting` rule is violated, and if
        `where` is provided, it selects which elements to copy.

        .. versionadded:: 1.7.0

        Parameters
        ----------
        dst : ndarray
            The array into which values are copied.
        src : array_like
            The array from which values are copied.
        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur when copying.

            * '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.
        where : array_like of bool, optional
            A boolean array which is broadcasted to match the dimensions
            of `dst`, and selects elements to copy from `src` to `dst`
            wherever it contains the value True.

        Examples
        --------
        >>> import numpy as np
        >>> A = np.array([4, 5, 6])
        >>> B = [1, 2, 3]
        >>> np.copyto(A, B)
        >>> A
        array([1, 2, 3])

        >>> A = np.array([[1, 2, 3], [4, 5, 6]])
        >>> B = [[4, 5, 6], [7, 8, 9]]
        >>> np.copyto(A, B)
        >>> A
        array([[4, 5, 6],
               [7, 8, 9]])

    corrcoef(x, y=None, rowvar=True, bias=<no value>, ddof=<no value>, *, dtype=None)
        Return Pearson product-moment correlation coefficients.

        Please refer to the documentation for `cov` for more detail.  The
        relationship between the correlation coefficient matrix, `R`, and the
        covariance matrix, `C`, is

        .. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } }

        The values of `R` are between -1 and 1, inclusive.

        Parameters
        ----------
        x : array_like
            A 1-D or 2-D array containing multiple variables and observations.
            Each row of `x` represents a variable, and each column a single
            observation of all those variables. Also see `rowvar` below.
        y : array_like, optional
            An additional set of variables and observations. `y` has the same
            shape as `x`.
        rowvar : bool, optional
            If `rowvar` is True (default), then each row represents a
            variable, with observations in the columns. Otherwise, the relationship
            is transposed: each column represents a variable, while the rows
            contain observations.
        bias : _NoValue, optional
            Has no effect, do not use.

            .. deprecated:: 1.10.0
        ddof : _NoValue, optional
            Has no effect, do not use.

            .. deprecated:: 1.10.0
        dtype : data-type, optional
            Data-type of the result. By default, the return data-type will have
            at least `numpy.float64` precision.

            .. versionadded:: 1.20

        Returns
        -------
        R : ndarray
            The correlation coefficient matrix of the variables.

        See Also
        --------
        cov : Covariance matrix

        Notes
        -----
        Due to floating point rounding the resulting array may not be Hermitian,
        the diagonal elements may not be 1, and the elements may not satisfy the
        inequality abs(a) <= 1. The real and imaginary parts are clipped to the
        interval [-1,  1] in an attempt to improve on that situation but is not
        much help in the complex case.

        This function accepts but discards arguments `bias` and `ddof`.  This is
        for backwards compatibility with previous versions of this function.  These
        arguments had no effect on the return values of the function and can be
        safely ignored in this and previous versions of numpy.

        Examples
        --------
        >>> import numpy as np

        In this example we generate two random arrays, ``xarr`` and ``yarr``, and
        compute the row-wise and column-wise Pearson correlation coefficients,
        ``R``. Since ``rowvar`` is  true by  default, we first find the row-wise
        Pearson correlation coefficients between the variables of ``xarr``.

        >>> import numpy as np
        >>> rng = np.random.default_rng(seed=42)
        >>> xarr = rng.random((3, 3))
        >>> xarr
        array([[0.77395605, 0.43887844, 0.85859792],
               [0.69736803, 0.09417735, 0.97562235],
               [0.7611397 , 0.78606431, 0.12811363]])
        >>> R1 = np.corrcoef(xarr)
        >>> R1
        array([[ 1.        ,  0.99256089, -0.68080986],
               [ 0.99256089,  1.        , -0.76492172],
               [-0.68080986, -0.76492172,  1.        ]])

        If we add another set of variables and observations ``yarr``, we can
        compute the row-wise Pearson correlation coefficients between the
        variables in ``xarr`` and ``yarr``.

        >>> yarr = rng.random((3, 3))
        >>> yarr
        array([[0.45038594, 0.37079802, 0.92676499],
               [0.64386512, 0.82276161, 0.4434142 ],
               [0.22723872, 0.55458479, 0.06381726]])
        >>> R2 = np.corrcoef(xarr, yarr)
        >>> R2
        array([[ 1.        ,  0.99256089, -0.68080986,  0.75008178, -0.934284  ,
                -0.99004057],
               [ 0.99256089,  1.        , -0.76492172,  0.82502011, -0.97074098,
                -0.99981569],
               [-0.68080986, -0.76492172,  1.        , -0.99507202,  0.89721355,
                 0.77714685],
               [ 0.75008178,  0.82502011, -0.99507202,  1.        , -0.93657855,
                -0.83571711],
               [-0.934284  , -0.97074098,  0.89721355, -0.93657855,  1.        ,
                 0.97517215],
               [-0.99004057, -0.99981569,  0.77714685, -0.83571711,  0.97517215,
                 1.        ]])

        Finally if we use the option ``rowvar=False``, the columns are now
        being treated as the variables and we will find the column-wise Pearson
        correlation coefficients between variables in ``xarr`` and ``yarr``.

        >>> R3 = np.corrcoef(xarr, yarr, rowvar=False)
        >>> R3
        array([[ 1.        ,  0.77598074, -0.47458546, -0.75078643, -0.9665554 ,
                 0.22423734],
               [ 0.77598074,  1.        , -0.92346708, -0.99923895, -0.58826587,
                -0.44069024],
               [-0.47458546, -0.92346708,  1.        ,  0.93773029,  0.23297648,
                 0.75137473],
               [-0.75078643, -0.99923895,  0.93773029,  1.        ,  0.55627469,
                 0.47536961],
               [-0.9665554 , -0.58826587,  0.23297648,  0.55627469,  1.        ,
                -0.46666491],
               [ 0.22423734, -0.44069024,  0.75137473,  0.47536961, -0.46666491,
                 1.        ]])

    correlate(a, v, mode='valid')
        Cross-correlation of two 1-dimensional sequences.

        This function computes the correlation as generally defined in signal
        processing texts [1]_:

        .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n

        with a and v sequences being zero-padded where necessary and
        :math:`\overline v` denoting complex conjugation.

        Parameters
        ----------
        a, v : array_like
            Input sequences.
        mode : {'valid', 'same', 'full'}, optional
            Refer to the `convolve` docstring.  Note that the default
            is 'valid', unlike `convolve`, which uses 'full'.

        Returns
        -------
        out : ndarray
            Discrete cross-correlation of `a` and `v`.

        See Also
        --------
        convolve : Discrete, linear convolution of two one-dimensional sequences.
        scipy.signal.correlate : uses FFT which has superior performance
            on large arrays.

        Notes
        -----
        The definition of correlation above is not unique and sometimes
        correlation may be defined differently. Another common definition is [1]_:

        .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}}

        which is related to :math:`c_k` by :math:`c'_k = c_{-k}`.

        `numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5)
        because it does not use the FFT to compute the convolution; in that case,
        `scipy.signal.correlate` might be preferable.

        References
        ----------
        .. [1] Wikipedia, "Cross-correlation",
               https://en.wikipedia.org/wiki/Cross-correlation

        Examples
        --------
        >>> import numpy as np
        >>> np.correlate([1, 2, 3], [0, 1, 0.5])
        array([3.5])
        >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
        array([2. ,  3.5,  3. ])
        >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
        array([0.5,  2. ,  3.5,  3. ,  0. ])

        Using complex sequences:

        >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
        array([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])

        Note that you get the time reversed, complex conjugated result
        (:math:`\overline{c_{-k}}`) when the two input sequences a and v change
        places:

        >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
        array([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])

    count_nonzero(a, axis=None, *, keepdims=False)
        Counts the number of non-zero values in the array ``a``.

        The word "non-zero" is in reference to the Python 2.x
        built-in method ``__nonzero__()`` (renamed ``__bool__()``
        in Python 3.x) of Python objects that tests an object's
        "truthfulness". For example, any number is considered
        truthful if it is nonzero, whereas any string is considered
        truthful if it is not the empty string. Thus, this function
        (recursively) counts how many elements in ``a`` (and in
        sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()``
        method evaluated to ``True``.

        Parameters
        ----------
        a : array_like
            The array for which to count non-zeros.
        axis : int or tuple, optional
            Axis or tuple of axes along which to count non-zeros.
            Default is None, meaning that non-zeros will be counted
            along a flattened version of ``a``.

            .. versionadded:: 1.12.0

        keepdims : bool, optional
            If this is set to True, the axes that are counted are left
            in the result as dimensions with size one. With this option,
            the result will broadcast correctly against the input array.

            .. versionadded:: 1.19.0

        Returns
        -------
        count : int or array of int
            Number of non-zero values in the array along a given axis.
            Otherwise, the total number of non-zero values in the array
            is returned.

        See Also
        --------
        nonzero : Return the coordinates of all the non-zero values.

        Examples
        --------
        >>> import numpy as np
        >>> np.count_nonzero(np.eye(4))
        4
        >>> a = np.array([[0, 1, 7, 0],
        ...               [3, 0, 2, 19]])
        >>> np.count_nonzero(a)
        5
        >>> np.count_nonzero(a, axis=0)
        array([1, 1, 2, 1])
        >>> np.count_nonzero(a, axis=1)
        array([2, 3])
        >>> np.count_nonzero(a, axis=1, keepdims=True)
        array([[2],
               [3]])

    cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, *, dtype=None)
        Estimate a covariance matrix, given data and weights.

        Covariance indicates the level to which two variables vary together.
        If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
        then the covariance matrix element :math:`C_{ij}` is the covariance of
        :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
        of :math:`x_i`.

        See the notes for an outline of the algorithm.

        Parameters
        ----------
        m : array_like
            A 1-D or 2-D array containing multiple variables and observations.
            Each row of `m` represents a variable, and each column a single
            observation of all those variables. Also see `rowvar` below.
        y : array_like, optional
            An additional set of variables and observations. `y` has the same form
            as that of `m`.
        rowvar : bool, optional
            If `rowvar` is True (default), then each row represents a
            variable, with observations in the columns. Otherwise, the relationship
            is transposed: each column represents a variable, while the rows
            contain observations.
        bias : bool, optional
            Default normalization (False) is by ``(N - 1)``, where ``N`` is the
            number of observations given (unbiased estimate). If `bias` is True,
            then normalization is by ``N``. These values can be overridden by using
            the keyword ``ddof`` in numpy versions >= 1.5.
        ddof : int, optional
            If not ``None`` the default value implied by `bias` is overridden.
            Note that ``ddof=1`` will return the unbiased estimate, even if both
            `fweights` and `aweights` are specified, and ``ddof=0`` will return
            the simple average. See the notes for the details. The default value
            is ``None``.

            .. versionadded:: 1.5
        fweights : array_like, int, optional
            1-D array of integer frequency weights; the number of times each
            observation vector should be repeated.

            .. versionadded:: 1.10
        aweights : array_like, optional
            1-D array of observation vector weights. These relative weights are
            typically large for observations considered "important" and smaller for
            observations considered less "important". If ``ddof=0`` the array of
            weights can be used to assign probabilities to observation vectors.

            .. versionadded:: 1.10
        dtype : data-type, optional
            Data-type of the result. By default, the return data-type will have
            at least `numpy.float64` precision.

            .. versionadded:: 1.20

        Returns
        -------
        out : ndarray
            The covariance matrix of the variables.

        See Also
        --------
        corrcoef : Normalized covariance matrix

        Notes
        -----
        Assume that the observations are in the columns of the observation
        array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
        steps to compute the weighted covariance are as follows::

            >>> m = np.arange(10, dtype=np.float64)
            >>> f = np.arange(10) * 2
            >>> a = np.arange(10) ** 2.
            >>> ddof = 1
            >>> w = f * a
            >>> v1 = np.sum(w)
            >>> v2 = np.sum(w * a)
            >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
            >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)

        Note that when ``a == 1``, the normalization factor
        ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
        as it should.

        Examples
        --------
        >>> import numpy as np

        Consider two variables, :math:`x_0` and :math:`x_1`, which
        correlate perfectly, but in opposite directions:

        >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
        >>> x
        array([[0, 1, 2],
               [2, 1, 0]])

        Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
        matrix shows this clearly:

        >>> np.cov(x)
        array([[ 1., -1.],
               [-1.,  1.]])

        Note that element :math:`C_{0,1}`, which shows the correlation between
        :math:`x_0` and :math:`x_1`, is negative.

        Further, note how `x` and `y` are combined:

        >>> x = [-2.1, -1,  4.3]
        >>> y = [3,  1.1,  0.12]
        >>> X = np.stack((x, y), axis=0)
        >>> np.cov(X)
        array([[11.71      , -4.286     ], # may vary
               [-4.286     ,  2.144133]])
        >>> np.cov(x, y)
        array([[11.71      , -4.286     ], # may vary
               [-4.286     ,  2.144133]])
        >>> np.cov(x)
        array(11.71)

    cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)
        Return the cross product of two (arrays of) vectors.

        The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
        to both `a` and `b`.  If `a` and `b` are arrays of vectors, the vectors
        are defined by the last axis of `a` and `b` by default, and these axes
        can have dimensions 2 or 3.  Where the dimension of either `a` or `b` is
        2, the third component of the input vector is assumed to be zero and the
        cross product calculated accordingly.  In cases where both input vectors
        have dimension 2, the z-component of the cross product is returned.

        Parameters
        ----------
        a : array_like
            Components of the first vector(s).
        b : array_like
            Components of the second vector(s).
        axisa : int, optional
            Axis of `a` that defines the vector(s).  By default, the last axis.
        axisb : int, optional
            Axis of `b` that defines the vector(s).  By default, the last axis.
        axisc : int, optional
            Axis of `c` containing the cross product vector(s).  Ignored if
            both input vectors have dimension 2, as the return is scalar.
            By default, the last axis.
        axis : int, optional
            If defined, the axis of `a`, `b` and `c` that defines the vector(s)
            and cross product(s).  Overrides `axisa`, `axisb` and `axisc`.

        Returns
        -------
        c : ndarray
            Vector cross product(s).

        Raises
        ------
        ValueError
            When the dimension of the vector(s) in `a` and/or `b` does not
            equal 2 or 3.

        See Also
        --------
        inner : Inner product
        outer : Outer product.
        linalg.cross : An Array API compatible variation of ``np.cross``,
                       which accepts (arrays of) 3-element vectors only.
        ix_ : Construct index arrays.

        Notes
        -----
        .. versionadded:: 1.9.0

        Supports full broadcasting of the inputs.

        Dimension-2 input arrays were deprecated in 2.0.0. If you do need this
        functionality, you can use::

            def cross2d(x, y):
                return x[..., 0] * y[..., 1] - x[..., 1] * y[..., 0]

        Examples
        --------
        Vector cross-product.

        >>> import numpy as np
        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> np.cross(x, y)
        array([-3,  6, -3])

        One vector with dimension 2.

        >>> x = [1, 2]
        >>> y = [4, 5, 6]
        >>> np.cross(x, y)
        array([12, -6, -3])

        Equivalently:

        >>> x = [1, 2, 0]
        >>> y = [4, 5, 6]
        >>> np.cross(x, y)
        array([12, -6, -3])

        Both vectors with dimension 2.

        >>> x = [1,2]
        >>> y = [4,5]
        >>> np.cross(x, y)
        array(-3)

        Multiple vector cross-products. Note that the direction of the cross
        product vector is defined by the *right-hand rule*.

        >>> x = np.array([[1,2,3], [4,5,6]])
        >>> y = np.array([[4,5,6], [1,2,3]])
        >>> np.cross(x, y)
        array([[-3,  6, -3],
               [ 3, -6,  3]])

        The orientation of `c` can be changed using the `axisc` keyword.

        >>> np.cross(x, y, axisc=0)
        array([[-3,  3],
               [ 6, -6],
               [-3,  3]])

        Change the vector definition of `x` and `y` using `axisa` and `axisb`.

        >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
        >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
        >>> np.cross(x, y)
        array([[ -6,  12,  -6],
               [  0,   0,   0],
               [  6, -12,   6]])
        >>> np.cross(x, y, axisa=0, axisb=0)
        array([[-24,  48, -24],
               [-30,  60, -30],
               [-36,  72, -36]])

    cumprod(a, axis=None, dtype=None, out=None)
        Return the cumulative product of elements along a given axis.

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int, optional
            Axis along which the cumulative product is computed.  By default
            the input is flattened.
        dtype : dtype, optional
            Type of the returned array, as well as of the accumulator in which
            the elements are multiplied.  If *dtype* is not specified, it
            defaults to the dtype of `a`, unless `a` has an integer dtype with
            a precision less than that of the default platform integer.  In
            that case, the default platform integer is used instead.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output
            but the type of the resulting values will be cast if necessary.

        Returns
        -------
        cumprod : ndarray
            A new array holding the result is returned unless `out` is
            specified, in which case a reference to out is returned.

        See Also
        --------
        cumulative_prod : Array API compatible alternative for ``cumprod``.
        :ref:`ufuncs-output-type`

        Notes
        -----
        Arithmetic is modular when using integer types, and no error is
        raised on overflow.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1,2,3])
        >>> np.cumprod(a) # intermediate results 1, 1*2
        ...               # total product 1*2*3 = 6
        array([1, 2, 6])
        >>> a = np.array([[1, 2, 3], [4, 5, 6]])
        >>> np.cumprod(a, dtype=float) # specify type of output
        array([   1.,    2.,    6.,   24.,  120.,  720.])

        The cumulative product for each column (i.e., over the rows) of `a`:

        >>> np.cumprod(a, axis=0)
        array([[ 1,  2,  3],
               [ 4, 10, 18]])

        The cumulative product for each row (i.e. over the columns) of `a`:

        >>> np.cumprod(a,axis=1)
        array([[  1,   2,   6],
               [  4,  20, 120]])

    cumsum(a, axis=None, dtype=None, out=None)
        Return the cumulative sum of the elements along a given axis.

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int, optional
            Axis along which the cumulative sum is computed. The default
            (None) is to compute the cumsum over the flattened array.
        dtype : dtype, optional
            Type of the returned array and of the accumulator in which the
            elements are summed.  If `dtype` is not specified, it defaults
            to the dtype of `a`, unless `a` has an integer dtype with a
            precision less than that of the default platform integer.  In
            that case, the default platform integer is used.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output
            but the type will be cast if necessary. See :ref:`ufuncs-output-type`
            for more details.

        Returns
        -------
        cumsum_along_axis : ndarray.
            A new array holding the result is returned unless `out` is
            specified, in which case a reference to `out` is returned. The
            result has the same size as `a`, and the same shape as `a` if
            `axis` is not None or `a` is a 1-d array.

        See Also
        --------
        cumulative_sum : Array API compatible alternative for ``cumsum``.
        sum : Sum array elements.
        trapezoid : Integration of array values using composite trapezoidal rule.
        diff : Calculate the n-th discrete difference along given axis.

        Notes
        -----
        Arithmetic is modular when using integer types, and no error is
        raised on overflow.

        ``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point
        values since ``sum`` may use a pairwise summation routine, reducing
        the roundoff-error. See `sum` for more information.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1,2,3], [4,5,6]])
        >>> a
        array([[1, 2, 3],
               [4, 5, 6]])
        >>> np.cumsum(a)
        array([ 1,  3,  6, 10, 15, 21])
        >>> np.cumsum(a, dtype=float)     # specifies type of output value(s)
        array([  1.,   3.,   6.,  10.,  15.,  21.])

        >>> np.cumsum(a,axis=0)      # sum over rows for each of the 3 columns
        array([[1, 2, 3],
               [5, 7, 9]])
        >>> np.cumsum(a,axis=1)      # sum over columns for each of the 2 rows
        array([[ 1,  3,  6],
               [ 4,  9, 15]])

        ``cumsum(b)[-1]`` may not be equal to ``sum(b)``

        >>> b = np.array([1, 2e-9, 3e-9] * 1000000)
        >>> b.cumsum()[-1]
        1000000.0050045159
        >>> b.sum()
        1000000.0050000029

    cumulative_prod(x, /, *, axis=None, dtype=None, out=None, include_initial=False)
        Return the cumulative product of elements along a given axis.

        This function is an Array API compatible alternative to `numpy.cumprod`.

        Parameters
        ----------
        x : array_like
            Input array.
        axis : int, optional
            Axis along which the cumulative product is computed. The default
            (None) is only allowed for one-dimensional arrays. For arrays
            with more than one dimension ``axis`` is required.
        dtype : dtype, optional
            Type of the returned array, as well as of the accumulator in which
            the elements are multiplied.  If ``dtype`` is not specified, it
            defaults to the dtype of ``x``, unless ``x`` has an integer dtype
            with a precision less than that of the default platform integer.
            In that case, the default platform integer is used instead.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output
            but the type of the resulting values will be cast if necessary.
            See :ref:`ufuncs-output-type` for more details.
        include_initial : bool, optional
            Boolean indicating whether to include the initial value (ones) as
            the first value in the output. With ``include_initial=True``
            the shape of the output is different than the shape of the input.
            Default: ``False``.

        Returns
        -------
        cumulative_prod_along_axis : ndarray
            A new array holding the result is returned unless ``out`` is
            specified, in which case a reference to ``out`` is returned. The
            result has the same shape as ``x`` if ``include_initial=False``.

        Notes
        -----
        Arithmetic is modular when using integer types, and no error is
        raised on overflow.

        Examples
        --------
        >>> a = np.array([1, 2, 3])
        >>> np.cumulative_prod(a)  # intermediate results 1, 1*2
        ...                        # total product 1*2*3 = 6
        array([1, 2, 6])
        >>> a = np.array([1, 2, 3, 4, 5, 6])
        >>> np.cumulative_prod(a, dtype=float) # specify type of output
        array([   1.,    2.,    6.,   24.,  120.,  720.])

        The cumulative product for each column (i.e., over the rows) of ``b``:

        >>> b = np.array([[1, 2, 3], [4, 5, 6]])
        >>> np.cumulative_prod(b, axis=0)
        array([[ 1,  2,  3],
               [ 4, 10, 18]])

        The cumulative product for each row (i.e. over the columns) of ``b``:

        >>> np.cumulative_prod(b, axis=1)
        array([[  1,   2,   6],
               [  4,  20, 120]])

    cumulative_sum(x, /, *, axis=None, dtype=None, out=None, include_initial=False)
        Return the cumulative sum of the elements along a given axis.

        This function is an Array API compatible alternative to `numpy.cumsum`.

        Parameters
        ----------
        x : array_like
            Input array.
        axis : int, optional
            Axis along which the cumulative sum is computed. The default
            (None) is only allowed for one-dimensional arrays. For arrays
            with more than one dimension ``axis`` is required.
        dtype : dtype, optional
            Type of the returned array and of the accumulator in which the
            elements are summed.  If ``dtype`` is not specified, it defaults
            to the dtype of ``x``, unless ``x`` has an integer dtype with
            a precision less than that of the default platform integer.
            In that case, the default platform integer is used.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output
            but the type will be cast if necessary. See :ref:`ufuncs-output-type`
            for more details.
        include_initial : bool, optional
            Boolean indicating whether to include the initial value (ones) as
            the first value in the output. With ``include_initial=True``
            the shape of the output is different than the shape of the input.
            Default: ``False``.

        Returns
        -------
        cumulative_sum_along_axis : ndarray
            A new array holding the result is returned unless ``out`` is
            specified, in which case a reference to ``out`` is returned. The
            result has the same shape as ``x`` if ``include_initial=False``.

        See Also
        --------
        sum : Sum array elements.
        trapezoid : Integration of array values using composite trapezoidal rule.
        diff : Calculate the n-th discrete difference along given axis.

        Notes
        -----
        Arithmetic is modular when using integer types, and no error is
        raised on overflow.

        ``cumulative_sum(a)[-1]`` may not be equal to ``sum(a)`` for
        floating-point values since ``sum`` may use a pairwise summation routine,
        reducing the roundoff-error. See `sum` for more information.

        Examples
        --------
        >>> a = np.array([1, 2, 3, 4, 5, 6])
        >>> a
        array([1, 2, 3, 4, 5, 6])
        >>> np.cumulative_sum(a)
        array([ 1,  3,  6, 10, 15, 21])
        >>> np.cumulative_sum(a, dtype=float)  # specifies type of output value(s)
        array([  1.,   3.,   6.,  10.,  15.,  21.])

        >>> b = np.array([[1, 2, 3], [4, 5, 6]])
        >>> np.cumulative_sum(b,axis=0)  # sum over rows for each of the 3 columns
        array([[1, 2, 3],
               [5, 7, 9]])
        >>> np.cumulative_sum(b,axis=1)  # sum over columns for each of the 2 rows
        array([[ 1,  3,  6],
               [ 4,  9, 15]])

        ``cumulative_sum(c)[-1]`` may not be equal to ``sum(c)``

        >>> c = np.array([1, 2e-9, 3e-9] * 1000000)
        >>> np.cumulative_sum(c)[-1]
        1000000.0050045159
        >>> c.sum()
        1000000.0050000029

    datetime_as_string(...)
        datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')

        Convert an array of datetimes into an array of strings.

        Parameters
        ----------
        arr : array_like of datetime64
            The array of UTC timestamps to format.
        unit : str
            One of None, 'auto', or
            a :ref:`datetime unit <arrays.dtypes.dateunits>`.
        timezone : {'naive', 'UTC', 'local'} or tzinfo
            Timezone information to use when displaying the datetime. If 'UTC',
            end with a Z to indicate UTC time. If 'local', convert to the local
            timezone first, and suffix with a +-#### timezone offset. If a tzinfo
            object, then do as with 'local', but use the specified timezone.
        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}
            Casting to allow when changing between datetime units.

        Returns
        -------
        str_arr : ndarray
            An array of strings the same shape as `arr`.

        Examples
        --------
        >>> import numpy as np
        >>> import pytz
        >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')
        >>> d
        array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',
               '2002-10-27T07:30'], dtype='datetime64[m]')

        Setting the timezone to UTC shows the same information, but with a Z suffix

        >>> np.datetime_as_string(d, timezone='UTC')
        array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',
               '2002-10-27T07:30Z'], dtype='<U35')

        Note that we picked datetimes that cross a DST boundary. Passing in a
        ``pytz`` timezone object will print the appropriate offset

        >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))
        array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',
               '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')

        Passing in a unit will change the precision

        >>> np.datetime_as_string(d, unit='h')
        array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],
              dtype='<U32')
        >>> np.datetime_as_string(d, unit='s')
        array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',
               '2002-10-27T07:30:00'], dtype='<U38')

        'casting' can be used to specify whether precision can be changed

        >>> np.datetime_as_string(d, unit='h', casting='safe')
        Traceback (most recent call last):
            ...
        TypeError: Cannot create a datetime string as units 'h' from a NumPy
        datetime with units 'm' according to the rule 'safe'

    datetime_data(...)
        datetime_data(dtype, /)

        Get information about the step size of a date or time type.

        The returned tuple can be passed as the second argument of `numpy.datetime64` and
        `numpy.timedelta64`.

        Parameters
        ----------
        dtype : dtype
            The dtype object, which must be a `datetime64` or `timedelta64` type.

        Returns
        -------
        unit : str
            The :ref:`datetime unit <arrays.dtypes.dateunits>` on which this dtype
            is based.
        count : int
            The number of base units in a step.

        Examples
        --------
        >>> import numpy as np
        >>> dt_25s = np.dtype('timedelta64[25s]')
        >>> np.datetime_data(dt_25s)
        ('s', 25)
        >>> np.array(10, dt_25s).astype('timedelta64[s]')
        array(250, dtype='timedelta64[s]')

        The result can be used to construct a datetime that uses the same units
        as a timedelta

        >>> np.datetime64('2010', np.datetime_data(dt_25s))
        np.datetime64('2010-01-01T00:00:00','25s')

    delete(arr, obj, axis=None)
        Return a new array with sub-arrays along an axis deleted. For a one
        dimensional array, this returns those entries not returned by
        `arr[obj]`.

        Parameters
        ----------
        arr : array_like
            Input array.
        obj : slice, int or array of ints
            Indicate indices of sub-arrays to remove along the specified axis.

            .. versionchanged:: 1.19.0
                Boolean indices are now treated as a mask of elements to remove,
                rather than being cast to the integers 0 and 1.

        axis : int, optional
            The axis along which to delete the subarray defined by `obj`.
            If `axis` is None, `obj` is applied to the flattened array.

        Returns
        -------
        out : ndarray
            A copy of `arr` with the elements specified by `obj` removed. Note
            that `delete` does not occur in-place. If `axis` is None, `out` is
            a flattened array.

        See Also
        --------
        insert : Insert elements into an array.
        append : Append elements at the end of an array.

        Notes
        -----
        Often it is preferable to use a boolean mask. For example:

        >>> arr = np.arange(12) + 1
        >>> mask = np.ones(len(arr), dtype=bool)
        >>> mask[[0,2,4]] = False
        >>> result = arr[mask,...]

        Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further
        use of `mask`.

        Examples
        --------
        >>> import numpy as np
        >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
        >>> arr
        array([[ 1,  2,  3,  4],
               [ 5,  6,  7,  8],
               [ 9, 10, 11, 12]])
        >>> np.delete(arr, 1, 0)
        array([[ 1,  2,  3,  4],
               [ 9, 10, 11, 12]])

        >>> np.delete(arr, np.s_[::2], 1)
        array([[ 2,  4],
               [ 6,  8],
               [10, 12]])
        >>> np.delete(arr, [1,3,5], None)
        array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])

    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
        --------
        >>> import numpy as np
        >>> 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]])

    diag_indices(n, ndim=2)
        Return the indices to access the main diagonal of an array.

        This returns a tuple of indices that can be used to access the main
        diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
        (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
        ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
        for ``i = [0..n-1]``.

        Parameters
        ----------
        n : int
          The size, along each dimension, of the arrays for which the returned
          indices can be used.

        ndim : int, optional
          The number of dimensions.

        See Also
        --------
        diag_indices_from

        Notes
        -----
        .. versionadded:: 1.4.0

        Examples
        --------
        >>> import numpy as np

        Create a set of indices to access the diagonal of a (4, 4) array:

        >>> di = np.diag_indices(4)
        >>> di
        (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
        >>> a = np.arange(16).reshape(4, 4)
        >>> a
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15]])
        >>> a[di] = 100
        >>> a
        array([[100,   1,   2,   3],
               [  4, 100,   6,   7],
               [  8,   9, 100,  11],
               [ 12,  13,  14, 100]])

        Now, we create indices to manipulate a 3-D array:

        >>> d3 = np.diag_indices(2, 3)
        >>> d3
        (array([0, 1]), array([0, 1]), array([0, 1]))

        And use it to set the diagonal of an array of zeros to 1:

        >>> a = np.zeros((2, 2, 2), dtype=int)
        >>> a[d3] = 1
        >>> a
        array([[[1, 0],
                [0, 0]],
               [[0, 0],
                [0, 1]]])

    diag_indices_from(arr)
        Return the indices to access the main diagonal of an n-dimensional array.

        See `diag_indices` for full details.

        Parameters
        ----------
        arr : array, at least 2-D

        See Also
        --------
        diag_indices

        Notes
        -----
        .. versionadded:: 1.4.0

        Examples
        --------
        >>> import numpy as np

        Create a 4 by 4 array.

        >>> a = np.arange(16).reshape(4, 4)
        >>> a
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15]])

        Get the indices of the diagonal elements.

        >>> di = np.diag_indices_from(a)
        >>> di
        (array([0, 1, 2, 3]), array([0, 1, 2, 3]))

        >>> a[di]
        array([ 0,  5, 10, 15])

        This is simply syntactic sugar for diag_indices.

        >>> np.diag_indices(a.shape[0])
        (array([0, 1, 2, 3]), array([0, 1, 2, 3]))

    diagflat(v, k=0)
        Create a two-dimensional array with the flattened input as a diagonal.

        Parameters
        ----------
        v : array_like
            Input data, which is flattened and set as the `k`-th
            diagonal of the output.
        k : int, optional
            Diagonal to set; 0, the default, corresponds to the "main" diagonal,
            a positive (negative) `k` giving the number of the diagonal above
            (below) the main.

        Returns
        -------
        out : ndarray
            The 2-D output array.

        See Also
        --------
        diag : MATLAB work-alike for 1-D and 2-D arrays.
        diagonal : Return specified diagonals.
        trace : Sum along diagonals.

        Examples
        --------
        >>> import numpy as np
        >>> np.diagflat([[1,2], [3,4]])
        array([[1, 0, 0, 0],
               [0, 2, 0, 0],
               [0, 0, 3, 0],
               [0, 0, 0, 4]])

        >>> np.diagflat([1,2], 1)
        array([[0, 1, 0],
               [0, 0, 2],
               [0, 0, 0]])

    diagonal(a, offset=0, axis1=0, axis2=1)
        Return specified diagonals.

        If `a` is 2-D, returns the diagonal of `a` with the given offset,
        i.e., the collection of elements of the form ``a[i, i+offset]``.  If
        `a` has more than two dimensions, then the axes specified by `axis1`
        and `axis2` are used to determine the 2-D sub-array whose diagonal is
        returned.  The shape of the resulting array can be determined by
        removing `axis1` and `axis2` and appending an index to the right equal
        to the size of the resulting diagonals.

        In versions of NumPy prior to 1.7, this function always returned a new,
        independent array containing a copy of the values in the diagonal.

        In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
        but depending on this fact is deprecated. Writing to the resulting
        array continues to work as it used to, but a FutureWarning is issued.

        Starting in NumPy 1.9 it returns a read-only view on the original array.
        Attempting to write to the resulting array will produce an error.

        In some future release, it will return a read/write view and writing to
        the returned array will alter your original array.  The returned array
        will have the same type as the input array.

        If you don't write to the array returned by this function, then you can
        just ignore all of the above.

        If you depend on the current behavior, then we suggest copying the
        returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead
        of just ``np.diagonal(a)``. This will work with both past and future
        versions of NumPy.

        Parameters
        ----------
        a : array_like
            Array from which the diagonals are taken.
        offset : int, optional
            Offset of the diagonal from the main diagonal.  Can be positive or
            negative.  Defaults to main diagonal (0).
        axis1 : int, optional
            Axis to be used as the first axis of the 2-D sub-arrays from which
            the diagonals should be taken.  Defaults to first axis (0).
        axis2 : int, optional
            Axis to be used as the second axis of the 2-D sub-arrays from
            which the diagonals should be taken. Defaults to second axis (1).

        Returns
        -------
        array_of_diagonals : ndarray
            If `a` is 2-D, then a 1-D array containing the diagonal and of the
            same type as `a` is returned unless `a` is a `matrix`, in which case
            a 1-D array rather than a (2-D) `matrix` is returned in order to
            maintain backward compatibility.

            If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`
            are removed, and a new axis inserted at the end corresponding to the
            diagonal.

        Raises
        ------
        ValueError
            If the dimension of `a` is less than 2.

        See Also
        --------
        diag : MATLAB work-a-like for 1-D and 2-D arrays.
        diagflat : Create diagonal arrays.
        trace : Sum along diagonals.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(4).reshape(2,2)
        >>> a
        array([[0, 1],
               [2, 3]])
        >>> a.diagonal()
        array([0, 3])
        >>> a.diagonal(1)
        array([1])

        A 3-D example:

        >>> a = np.arange(8).reshape(2,2,2); a
        array([[[0, 1],
                [2, 3]],
               [[4, 5],
                [6, 7]]])
        >>> a.diagonal(0,  # Main diagonals of two arrays created by skipping
        ...            0,  # across the outer(left)-most axis last and
        ...            1)  # the "middle" (row) axis first.
        array([[0, 6],
               [1, 7]])

        The sub-arrays whose main diagonals we just obtained; note that each
        corresponds to fixing the right-most (column) axis, and that the
        diagonals are "packed" in rows.

        >>> a[:,:,0]  # main diagonal is [0 6]
        array([[0, 2],
               [4, 6]])
        >>> a[:,:,1]  # main diagonal is [1 7]
        array([[1, 3],
               [5, 7]])

        The anti-diagonal can be obtained by reversing the order of elements
        using either `numpy.flipud` or `numpy.fliplr`.

        >>> a = np.arange(9).reshape(3, 3)
        >>> a
        array([[0, 1, 2],
               [3, 4, 5],
               [6, 7, 8]])
        >>> np.fliplr(a).diagonal()  # Horizontal flip
        array([2, 4, 6])
        >>> np.flipud(a).diagonal()  # Vertical flip
        array([6, 4, 2])

        Note that the order in which the diagonal is retrieved varies depending
        on the flip function.

    diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)
        Calculate the n-th discrete difference along the given axis.

        The first difference is given by ``out[i] = a[i+1] - a[i]`` 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.
        prepend, append : array_like, optional
            Values to prepend or append to `a` along axis prior to
            performing the difference.  Scalar values are expanded to
            arrays with length 1 in the direction of axis and the shape
            of the input array in along all other axes.  Otherwise the
            dimension and shape must match `a` except along axis.

            .. versionadded:: 1.16.0

        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,...]
        255

        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
        --------
        >>> import numpy as np
        >>> 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]')

    digitize(x, bins, right=False)
        Return the indices of the bins to which each value in input array belongs.

        =========  =============  ============================
        `right`    order of bins  returned index `i` satisfies
        =========  =============  ============================
        ``False``  increasing     ``bins[i-1] <= x < bins[i]``
        ``True``   increasing     ``bins[i-1] < x <= bins[i]``
        ``False``  decreasing     ``bins[i-1] > x >= bins[i]``
        ``True``   decreasing     ``bins[i-1] >= x > bins[i]``
        =========  =============  ============================

        If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is
        returned as appropriate.

        Parameters
        ----------
        x : array_like
            Input array to be binned. Prior to NumPy 1.10.0, this array had to
            be 1-dimensional, but can now have any shape.
        bins : array_like
            Array of bins. It has to be 1-dimensional and monotonic.
        right : bool, optional
            Indicating whether the intervals include the right or the left bin
            edge. Default behavior is (right==False) indicating that the interval
            does not include the right edge. The left bin end is open in this
            case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
            monotonically increasing bins.

        Returns
        -------
        indices : ndarray of ints
            Output array of indices, of same shape as `x`.

        Raises
        ------
        ValueError
            If `bins` is not monotonic.
        TypeError
            If the type of the input is complex.

        See Also
        --------
        bincount, histogram, unique, searchsorted

        Notes
        -----
        If values in `x` are such that they fall outside the bin range,
        attempting to index `bins` with the indices that `digitize` returns
        will result in an IndexError.

        .. versionadded:: 1.10.0

        `numpy.digitize` is  implemented in terms of `numpy.searchsorted`.
        This means that a binary search is used to bin the values, which scales
        much better for larger number of bins than the previous linear search.
        It also removes the requirement for the input array to be 1-dimensional.

        For monotonically *increasing* `bins`, the following are equivalent::

            np.digitize(x, bins, right=True)
            np.searchsorted(bins, x, side='left')

        Note that as the order of the arguments are reversed, the side must be too.
        The `searchsorted` call is marginally faster, as it does not do any
        monotonicity checks. Perhaps more importantly, it supports all dtypes.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([0.2, 6.4, 3.0, 1.6])
        >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
        >>> inds = np.digitize(x, bins)
        >>> inds
        array([1, 4, 3, 2])
        >>> for n in range(x.size):
        ...   print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]])
        ...
        0.0 <= 0.2 < 1.0
        4.0 <= 6.4 < 10.0
        2.5 <= 3.0 < 4.0
        1.0 <= 1.6 < 2.5

        >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])
        >>> bins = np.array([0, 5, 10, 15, 20])
        >>> np.digitize(x,bins,right=True)
        array([1, 2, 3, 4, 4])
        >>> np.digitize(x,bins,right=False)
        array([1, 3, 3, 4, 5])

    dot(...)
        dot(a, b, out=None)

        Dot product of two arrays. Specifically,

        - If both `a` and `b` are 1-D arrays, it is inner product of vectors
          (without complex conjugation).

        - If both `a` and `b` are 2-D arrays, it is matrix multiplication,
          but using :func:`matmul` or ``a @ b`` is preferred.

        - If either `a` or `b` is 0-D (scalar), it is equivalent to
          :func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is
          preferred.

        - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
          the last axis of `a` and `b`.

        - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
          sum product over the last axis of `a` and the second-to-last axis of
          `b`::

            dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

        It uses an optimized BLAS library when possible (see `numpy.linalg`).

        Parameters
        ----------
        a : array_like
            First argument.
        b : array_like
            Second argument.
        out : ndarray, optional
            Output argument. This must have the exact kind that would be returned
            if it was not used. In particular, it must have the right type, must be
            C-contiguous, and its dtype must be the dtype that would be returned
            for `dot(a,b)`. This is a performance feature. Therefore, if these
            conditions are not met, an exception is raised, instead of attempting
            to be flexible.

        Returns
        -------
        output : ndarray
            Returns the dot product of `a` and `b`.  If `a` and `b` are both
            scalars or both 1-D arrays then a scalar is returned; otherwise
            an array is returned.
            If `out` is given, then it is returned.

        Raises
        ------
        ValueError
            If the last dimension of `a` is not the same size as
            the second-to-last dimension of `b`.

        See Also
        --------
        vdot : Complex-conjugating dot product.
        tensordot : Sum products over arbitrary axes.
        einsum : Einstein summation convention.
        matmul : '@' operator as method with out parameter.
        linalg.multi_dot : Chained dot product.

        Examples
        --------
        >>> import numpy as np
        >>> np.dot(3, 4)
        12

        Neither argument is complex-conjugated:

        >>> np.dot([2j, 3j], [2j, 3j])
        (-13+0j)

        For 2-D arrays it is the matrix product:

        >>> a = [[1, 0], [0, 1]]
        >>> b = [[4, 1], [2, 2]]
        >>> np.dot(a, b)
        array([[4, 1],
               [2, 2]])

        >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
        >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
        >>> np.dot(a, b)[2,3,2,1,2,2]
        499128
        >>> sum(a[2,3,2,:] * b[1,2,:,2])
        499128

    dsplit(ary, indices_or_sections)
        Split array into multiple sub-arrays along the 3rd axis (depth).

        Please refer to the `split` documentation.  `dsplit` is equivalent
        to `split` with ``axis=2``, the array is always split along the third
        axis provided the array dimension is greater than or equal to 3.

        See Also
        --------
        split : Split an array into multiple sub-arrays of equal size.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(16.0).reshape(2, 2, 4)
        >>> x
        array([[[ 0.,   1.,   2.,   3.],
                [ 4.,   5.,   6.,   7.]],
               [[ 8.,   9.,  10.,  11.],
                [12.,  13.,  14.,  15.]]])
        >>> np.dsplit(x, 2)
        [array([[[ 0.,  1.],
                [ 4.,  5.]],
               [[ 8.,  9.],
                [12., 13.]]]), array([[[ 2.,  3.],
                [ 6.,  7.]],
               [[10., 11.],
                [14., 15.]]])]
        >>> np.dsplit(x, np.array([3, 6]))
        [array([[[ 0.,   1.,   2.],
                [ 4.,   5.,   6.]],
               [[ 8.,   9.,  10.],
                [12.,  13.,  14.]]]),
         array([[[ 3.],
                [ 7.]],
               [[11.],
                [15.]]]),
        array([], shape=(2, 2, 0), dtype=float64)]

    dstack(tup)
        Stack arrays in sequence depth wise (along third axis).

        This is equivalent to concatenation along the third axis after 2-D arrays
        of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
        `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
        `dsplit`.

        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 arrays
            The arrays must have the same shape along all but the third axis.
            1-D or 2-D arrays must have the same shape.

        Returns
        -------
        stacked : ndarray
            The array formed by stacking the given arrays, will be at least 3-D.

        See Also
        --------
        concatenate : Join a sequence of arrays along an existing axis.
        stack : Join a sequence of arrays along a new axis.
        block : Assemble an nd-array from nested lists of blocks.
        vstack : Stack arrays in sequence vertically (row wise).
        hstack : Stack arrays in sequence horizontally (column wise).
        column_stack : Stack 1-D arrays as columns into a 2-D array.
        dsplit : Split array along third axis.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array((1,2,3))
        >>> b = np.array((2,3,4))
        >>> np.dstack((a,b))
        array([[[1, 2],
                [2, 3],
                [3, 4]]])

        >>> a = np.array([[1],[2],[3]])
        >>> b = np.array([[2],[3],[4]])
        >>> np.dstack((a,b))
        array([[[1, 2]],
               [[2, 3]],
               [[3, 4]]])

    ediff1d(ary, to_end=None, to_begin=None)
        The differences between consecutive elements of an array.

        Parameters
        ----------
        ary : array_like
            If necessary, will be flattened before the differences are taken.
        to_end : array_like, optional
            Number(s) to append at the end of the returned differences.
        to_begin : array_like, optional
            Number(s) to prepend at the beginning of the returned differences.

        Returns
        -------
        ediff1d : ndarray
            The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.

        See Also
        --------
        diff, gradient

        Notes
        -----
        When applied to masked arrays, this function drops the mask information
        if the `to_begin` and/or `to_end` parameters are used.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([1, 2, 4, 7, 0])
        >>> np.ediff1d(x)
        array([ 1,  2,  3, -7])

        >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
        array([-99,   1,   2, ...,  -7,  88,  99])

        The returned array is always 1D.

        >>> y = [[1, 2, 4], [1, 6, 24]]
        >>> np.ediff1d(y)
        array([ 1,  2, -3,  5, 18])

    einsum(*operands, out=None, optimize=False, **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,
        linear algebraic array operations can be represented in a simple fashion.
        In *implicit* mode `einsum` computes these values.

        In *explicit* mode, `einsum` provides further flexibility to compute
        other array operations that might not be considered classical Einstein
        summation operations, by disabling, or forcing summation over specified
        subscript labels.

        See the notes and examples for clarification.

        Parameters
        ----------
        subscripts : str
            Specifies the subscripts for summation as comma separated list of
            subscript labels. An implicit (classical Einstein summation)
            calculation is performed unless the explicit indicator '->' is
            included as well as subscript labels of the precise output form.
        operands : list of array_like
            These are the arrays for the operation.
        out : ndarray, 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. Defaults to False.

        Returns
        -------
        output : ndarray
            The calculation based on the Einstein summation convention.

        See Also
        --------
        einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
        einsum:
            Similar verbose interface is provided by the
            `einops <https://github.com/arogozhnikov/einops>`_ package to cover
            additional operations: transpose, reshape/flatten, repeat/tile,
            squeeze/unsqueeze and reductions.
            The `opt_einsum <https://optimized-einsum.readthedocs.io/en/stable/>`_
            optimizes contraction order for einsum-like expressions
            in backend-agnostic manner.

        Notes
        -----
        .. versionadded:: 1.6.0

        The Einstein summation convention can be used to compute
        many multi-dimensional, linear algebraic array operations. `einsum`
        provides a succinct way of representing these.

        A non-exhaustive list of these operations,
        which can be computed by `einsum`, is shown below along with examples:

        * Trace of an array, :py:func:`numpy.trace`.
        * Return a diagonal, :py:func:`numpy.diag`.
        * Array axis summations, :py:func:`numpy.sum`.
        * Transpositions and permutations, :py:func:`numpy.transpose`.
        * Matrix multiplication and dot product, :py:func:`numpy.matmul`
            :py:func:`numpy.dot`.
        * Vector inner and outer products, :py:func:`numpy.inner`
            :py:func:`numpy.outer`.
        * Broadcasting, element-wise and scalar multiplication,
            :py:func:`numpy.multiply`.
        * Tensor contractions, :py:func:`numpy.tensordot`.
        * Chained array operations, in efficient calculation order,
            :py:func:`numpy.einsum_path`.

        The subscripts string is a comma-separated list of subscript labels,
        where each label refers to a dimension of the corresponding operand.
        Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)``
        is equivalent to :py:func:`np.inner(a,b) <numpy.inner>`. If a label
        appears only once, it is not summed, so ``np.einsum('i', a)``
        produces a view of ``a`` with no changes. A further example
        ``np.einsum('ij,jk', a, b)`` describes traditional matrix multiplication
        and is equivalent to :py:func:`np.matmul(a,b) <numpy.matmul>`.
        Repeated subscript labels in one operand take the diagonal.
        For example, ``np.einsum('ii', a)`` is equivalent to
        :py:func:`np.trace(a) <numpy.trace>`.

        In *implicit mode*, the chosen subscripts are important
        since the axes of the output are reordered alphabetically.  This
        means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
        ``np.einsum('ji', a)`` takes its transpose. Additionally,
        ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,
        ``np.einsum('ij,jh', a, b)`` returns the transpose of the
        multiplication since subscript 'h' precedes subscript 'i'.

        In *explicit mode* the output can be directly controlled by
        specifying output subscript labels.  This requires the
        identifier '->' as well as the list of output subscript labels.
        This feature increases the flexibility of the function since
        summing can be disabled or forced when required. The call
        ``np.einsum('i->', a)`` is like :py:func:`np.sum(a) <numpy.sum>`
        if ``a`` is a 1-D array, and ``np.einsum('ii->i', a)``
        is like :py:func:`np.diag(a) <numpy.diag>` if ``a`` is a square 2-D array.
        The difference is that `einsum` does not allow broadcasting by default.
        Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the
        order of the output subscript labels and therefore returns matrix
        multiplication, unlike the example above in implicit mode.

        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)``.
        ``np.einsum('...i->...', a)`` is like
        :py:func:`np.sum(a, axis=-1) <numpy.sum>` for array ``a`` of any shape.
        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, one 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 (changed in version 1.10.0).

        `einsum` also provides an alternative way to provide the subscripts and
        operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``.
        If the output shape is not provided in this format `einsum` will be
        calculated in implicit mode, otherwise it will be performed explicitly.
        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 :py:func:`np.swapaxes(a, 0, 2) <numpy.swapaxes>`
        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.

        Typically a 'greedy' algorithm is applied which empirical tests have shown
        returns the optimal path in the majority of cases. In some cases 'optimal'
        will return the superlative path through a more expensive, exhaustive
        search. For iterative calculations it may be advisable to calculate
        the optimal path once and reuse that path by supplying it as an argument.
        An example is given below.

        See :py:func:`numpy.einsum_path` for more details.

        Examples
        --------
        >>> a = np.arange(25).reshape(5,5)
        >>> b = np.arange(5)
        >>> c = np.arange(6).reshape(2,3)

        Trace of a matrix:

        >>> np.einsum('ii', a)
        60
        >>> np.einsum(a, [0,0])
        60
        >>> np.trace(a)
        60

        Extract the diagonal (requires explicit form):

        >>> 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])

        Sum over an axis (requires explicit form):

        >>> np.einsum('ij->i', a)
        array([ 10,  35,  60,  85, 110])
        >>> np.einsum(a, [0,1], [0])
        array([ 10,  35,  60,  85, 110])
        >>> np.sum(a, axis=1)
        array([ 10,  35,  60,  85, 110])

        For higher dimensional arrays summing a single axis can be done
        with ellipsis:

        >>> np.einsum('...j->...', a)
        array([ 10,  35,  60,  85, 110])
        >>> np.einsum(a, [Ellipsis,1], [Ellipsis])
        array([ 10,  35,  60,  85, 110])

        Compute a matrix transpose, or reorder any number of axes:

        >>> np.einsum('ji', c)
        array([[0, 3],
               [1, 4],
               [2, 5]])
        >>> np.einsum('ij->ji', c)
        array([[0, 3],
               [1, 4],
               [2, 5]])
        >>> np.einsum(c, [1,0])
        array([[0, 3],
               [1, 4],
               [2, 5]])
        >>> np.transpose(c)
        array([[0, 3],
               [1, 4],
               [2, 5]])

        Vector inner products:

        >>> np.einsum('i,i', b, b)
        30
        >>> np.einsum(b, [0], b, [0])
        30
        >>> np.inner(b,b)
        30

        Matrix vector multiplication:

        >>> 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])

        Broadcasting and scalar multiplication:

        >>> 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]])

        Vector outer product:

        >>> 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]])

        Tensor contraction:

        >>> 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.]])

        Writeable returned arrays (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.]])

        Example of ellipsis use:

        >>> 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]])

        Chained array operations. For more complicated contractions, speed ups
        might be achieved by repeatedly computing a 'greedy' path or pre-computing
        the 'optimal' path and repeatedly applying it, using an `einsum_path`
        insertion (since version 1.12.0). Performance improvements can be
        particularly significant with larger arrays:

        >>> a = np.ones(64).reshape(2,4,8)

        Basic `einsum`: ~1520ms  (benchmarked on 3.1GHz Intel i5.)

        >>> for iteration in range(500):
        ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)

        Sub-optimal `einsum` (due to repeated path calculation time): ~330ms

        >>> for iteration in range(500):
        ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a,
        ...         optimize='optimal')

        Greedy `einsum` (faster optimal path approximation): ~160ms

        >>> for iteration in range(500):
        ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')

        Optimal `einsum` (best usage pattern in some use cases): ~110ms

        >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a,
        ...     optimize='optimal')[0]
        >>> for iteration in range(500):
        ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)

    einsum_path(*operands, optimize='greedy', einsum_call=False)
        einsum_path(subscripts, *operands, optimize='greedy')

        Evaluates the lowest cost contraction order for an einsum expression by
        considering the creation of intermediate arrays.

        Parameters
        ----------
        subscripts : str
            Specifies the subscripts for summation.
        *operands : list of array_like
            These are the arrays for the operation.
        optimize : {bool, list, tuple, 'greedy', 'optimal'}
            Choose the type of path. If a tuple is provided, the second argument is
            assumed to be the maximum intermediate size created. If only a single
            argument is provided the largest input or output array size is used
            as a maximum intermediate size.

            * if a list is given that starts with ``einsum_path``, uses this as the
              contraction path
            * if False no optimization is taken
            * if True defaults to the 'greedy' algorithm
            * 'optimal' An algorithm that combinatorially explores all possible
              ways of contracting the listed tensors and chooses the least costly
              path. Scales exponentially with the number of terms in the
              contraction.
            * 'greedy' An algorithm that chooses the best pair contraction
              at each step. Effectively, this algorithm searches the largest inner,
              Hadamard, and then outer products at each step. Scales cubically with
              the number of terms in the contraction. Equivalent to the 'optimal'
              path for most contractions.

            Default is 'greedy'.

        Returns
        -------
        path : list of tuples
            A list representation of the einsum path.
        string_repr : str
            A printable representation of the einsum path.

        Notes
        -----
        The resulting path indicates which terms of the input contraction should be
        contracted first, the result of this contraction is then appended to the
        end of the contraction list. This list can then be iterated over until all
        intermediate contractions are complete.

        See Also
        --------
        einsum, linalg.multi_dot

        Examples
        --------

        We can begin with a chain dot example. In this case, it is optimal to
        contract the ``b`` and ``c`` tensors first as represented by the first
        element of the path ``(1, 2)``. The resulting tensor is added to the end
        of the contraction and the remaining contraction ``(0, 1)`` is then
        completed.

        >>> np.random.seed(123)
        >>> a = np.random.rand(2, 2)
        >>> b = np.random.rand(2, 5)
        >>> c = np.random.rand(5, 2)
        >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
        >>> print(path_info[0])
        ['einsum_path', (1, 2), (0, 1)]
        >>> print(path_info[1])
          Complete contraction:  ij,jk,kl->il # may vary
                 Naive scaling:  4
             Optimized scaling:  3
              Naive FLOP count:  1.600e+02
          Optimized FLOP count:  5.600e+01
           Theoretical speedup:  2.857
          Largest intermediate:  4.000e+00 elements
        -------------------------------------------------------------------------
        scaling                  current                                remaining
        -------------------------------------------------------------------------
           3                   kl,jk->jl                                ij,jl->il
           3                   jl,ij->il                                   il->il


        A more complex index transformation example.

        >>> I = np.random.rand(10, 10, 10, 10)
        >>> C = np.random.rand(10, 10)
        >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
        ...                            optimize='greedy')

        >>> print(path_info[0])
        ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
        >>> print(path_info[1])
          Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
                 Naive scaling:  8
             Optimized scaling:  5
              Naive FLOP count:  8.000e+08
          Optimized FLOP count:  8.000e+05
           Theoretical speedup:  1000.000
          Largest intermediate:  1.000e+04 elements
        --------------------------------------------------------------------------
        scaling                  current                                remaining
        --------------------------------------------------------------------------
           5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
           5               bcde,fb->cdef                         gc,hd,cdef->efgh
           5               cdef,gc->defg                            hd,defg->efgh
           5               defg,hd->efgh                               efgh->efgh

    empty(...)
        empty(shape, dtype=float, order='C', *, device=None, like=None)

        Return a new array of given shape and type, without initializing entries.

        Parameters
        ----------
        shape : int or tuple of int
            Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
        dtype : data-type, optional
            Desired output data-type for the array, e.g, `numpy.int8`. Default is
            `numpy.float64`.
        order : {'C', 'F'}, optional, default: 'C'
            Whether to store multi-dimensional data in row-major
            (C-style) or column-major (Fortran-style) order in
            memory.
        device : str, optional
            The device on which to place the created array. Default: ``None``.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Array of uninitialized (arbitrary) data of the given shape, dtype, and
            order.  Object arrays will be initialized to None.

        See Also
        --------
        empty_like : Return an empty array with shape and type of input.
        ones : Return a new array setting values to one.
        zeros : Return a new array setting values to zero.
        full : Return a new array of given shape filled with value.

        Notes
        -----
        Unlike other array creation functions (e.g. `zeros`, `ones`, `full`),
        `empty` does not initialize the values of the array, and may therefore be
        marginally faster. However, the values stored in the newly allocated array
        are arbitrary. For reproducible behavior, be sure to set each element of
        the array before reading.

        Examples
        --------
        >>> import numpy as np
        >>> np.empty([2, 2])
        array([[ -9.74499359e+001,   6.69583040e-309],
               [  2.13182611e-314,   3.06959433e-309]])         #uninitialized

        >>> np.empty([2, 2], dtype=int)
        array([[-1073741821, -1067949133],
               [  496041986,    19249760]])                     #uninitialized

    empty_like(...)
        empty_like(prototype, dtype=None, order='K', subok=True, shape=None, *,
                   device=None)

        Return a new array with the same shape and type as a given array.

        Parameters
        ----------
        prototype : array_like
            The shape and data-type of `prototype` 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 `prototype` is Fortran
            contiguous, 'C' otherwise. 'K' means match the layout of `prototype`
            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 `prototype`, otherwise it will be a base-class array. Defaults
            to True.
        shape : int or sequence of ints, optional.
            Overrides the shape of the result. If order='K' and the number of
            dimensions is unchanged, will try to keep order, otherwise,
            order='C' is implied.

            .. versionadded:: 1.17.0
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0

        Returns
        -------
        out : ndarray
            Array of uninitialized (arbitrary) data with the same
            shape and type as `prototype`.

        See Also
        --------
        ones_like : Return an array of ones with shape and type of input.
        zeros_like : Return an array of zeros with shape and type of input.
        full_like : Return a new array with shape of input filled with value.
        empty : Return a new uninitialized array.

        Notes
        -----
        Unlike other array creation functions (e.g. `zeros_like`, `ones_like`,
        `full_like`), `empty_like` does not initialize the values of the array,
        and may therefore be marginally faster. However, the values stored in the
        newly allocated array are arbitrary. For reproducible behavior, be sure
        to set each element of the array before reading.

        Examples
        --------
        >>> import numpy as np
        >>> a = ([1,2,3], [4,5,6])                         # a is array-like
        >>> np.empty_like(a)
        array([[-1073741821, -1073741821,           3],    # uninitialized
               [          0,           0, -1073741821]])
        >>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
        >>> np.empty_like(a)
        array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
               [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])

    expand_dims(a, axis)
        Expand the shape of an array.

        Insert a new axis that will appear at the `axis` position in the expanded
        array shape.

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int or tuple of ints
            Position in the expanded axes where the new axis (or axes) is placed.

            .. deprecated:: 1.13.0
                Passing an axis where ``axis > a.ndim`` will be treated as
                ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
                be treated as ``axis == 0``. This behavior is deprecated.

            .. versionchanged:: 1.18.0
                A tuple of axes is now supported.  Out of range axes as
                described above are now forbidden and raise an
                `~exceptions.AxisError`.

        Returns
        -------
        result : ndarray
            View of `a` with the number of dimensions increased.

        See Also
        --------
        squeeze : The inverse operation, removing singleton dimensions
        reshape : Insert, remove, and combine dimensions, and resize existing ones
        atleast_1d, atleast_2d, atleast_3d

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([1, 2])
        >>> x.shape
        (2,)

        The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:

        >>> y = np.expand_dims(x, axis=0)
        >>> y
        array([[1, 2]])
        >>> y.shape
        (1, 2)

        The following is equivalent to ``x[:, np.newaxis]``:

        >>> y = np.expand_dims(x, axis=1)
        >>> y
        array([[1],
               [2]])
        >>> y.shape
        (2, 1)

        ``axis`` may also be a tuple:

        >>> y = np.expand_dims(x, axis=(0, 1))
        >>> y
        array([[[1, 2]]])

        >>> y = np.expand_dims(x, axis=(2, 0))
        >>> y
        array([[[1],
                [2]]])

        Note that some examples may use ``None`` instead of ``np.newaxis``.  These
        are the same objects:

        >>> np.newaxis is None
        True

    extract(condition, arr)
        Return the elements of an array that satisfy some condition.

        This is equivalent to ``np.compress(ravel(condition), ravel(arr))``.  If
        `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.

        Note that `place` does the exact opposite of `extract`.

        Parameters
        ----------
        condition : array_like
            An array whose nonzero or True entries indicate the elements of `arr`
            to extract.
        arr : array_like
            Input array of the same size as `condition`.

        Returns
        -------
        extract : ndarray
            Rank 1 array of values from `arr` where `condition` is True.

        See Also
        --------
        take, put, copyto, compress, place

        Examples
        --------
        >>> import numpy as np
        >>> arr = np.arange(12).reshape((3, 4))
        >>> arr
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11]])
        >>> condition = np.mod(arr, 3)==0
        >>> condition
        array([[ True, False, False,  True],
               [False, False,  True, False],
               [False,  True, False, False]])
        >>> np.extract(condition, arr)
        array([0, 3, 6, 9])


        If `condition` is boolean:

        >>> arr[condition]
        array([0, 3, 6, 9])

    eye(N, M=None, k=0, dtype=<class 'float'>, order='C', *, device=None, like=None)
        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
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.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
        --------
        >>> import numpy as np
        >>> 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.]])

    fill_diagonal(a, val, wrap=False)
        Fill the main diagonal of the given array of any dimensionality.

        For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
        values ``a[i, ..., i]`` with indices ``i`` all identical.  This function
        modifies the input array in-place without returning a value.

        Parameters
        ----------
        a : array, at least 2-D.
          Array whose diagonal is to be filled in-place.
        val : scalar or array_like
          Value(s) to write on the diagonal. If `val` is scalar, the value is
          written along the diagonal. If array-like, the flattened `val` is
          written along the diagonal, repeating if necessary to fill all
          diagonal entries.

        wrap : bool
          For tall matrices in NumPy version up to 1.6.2, the
          diagonal "wrapped" after N columns. You can have this behavior
          with this option. This affects only tall matrices.

        See also
        --------
        diag_indices, diag_indices_from

        Notes
        -----
        .. versionadded:: 1.4.0

        This functionality can be obtained via `diag_indices`, but internally
        this version uses a much faster implementation that never constructs the
        indices and uses simple slicing.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.zeros((3, 3), int)
        >>> np.fill_diagonal(a, 5)
        >>> a
        array([[5, 0, 0],
               [0, 5, 0],
               [0, 0, 5]])

        The same function can operate on a 4-D array:

        >>> a = np.zeros((3, 3, 3, 3), int)
        >>> np.fill_diagonal(a, 4)

        We only show a few blocks for clarity:

        >>> a[0, 0]
        array([[4, 0, 0],
               [0, 0, 0],
               [0, 0, 0]])
        >>> a[1, 1]
        array([[0, 0, 0],
               [0, 4, 0],
               [0, 0, 0]])
        >>> a[2, 2]
        array([[0, 0, 0],
               [0, 0, 0],
               [0, 0, 4]])

        The wrap option affects only tall matrices:

        >>> # tall matrices no wrap
        >>> a = np.zeros((5, 3), int)
        >>> np.fill_diagonal(a, 4)
        >>> a
        array([[4, 0, 0],
               [0, 4, 0],
               [0, 0, 4],
               [0, 0, 0],
               [0, 0, 0]])

        >>> # tall matrices wrap
        >>> a = np.zeros((5, 3), int)
        >>> np.fill_diagonal(a, 4, wrap=True)
        >>> a
        array([[4, 0, 0],
               [0, 4, 0],
               [0, 0, 4],
               [0, 0, 0],
               [4, 0, 0]])

        >>> # wide matrices
        >>> a = np.zeros((3, 5), int)
        >>> np.fill_diagonal(a, 4, wrap=True)
        >>> a
        array([[4, 0, 0, 0, 0],
               [0, 4, 0, 0, 0],
               [0, 0, 4, 0, 0]])

        The anti-diagonal can be filled by reversing the order of elements
        using either `numpy.flipud` or `numpy.fliplr`.

        >>> a = np.zeros((3, 3), int);
        >>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
        >>> a
        array([[0, 0, 1],
               [0, 2, 0],
               [3, 0, 0]])
        >>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
        >>> a
        array([[0, 0, 3],
               [0, 2, 0],
               [1, 0, 0]])

        Note that the order in which the diagonal is filled varies depending
        on the flip function.

    fix(x, out=None)
        Round to nearest integer towards zero.

        Round an array of floats element-wise to nearest integer towards zero.
        The rounded values have the same data-type as the input.

        Parameters
        ----------
        x : array_like
            An array to be rounded
        out : ndarray, optional
            A location into which the result is stored. If provided, it must have
            a shape that the input broadcasts to. If not provided or None, a
            freshly-allocated array is returned.

        Returns
        -------
        out : ndarray of floats
            An array with the same dimensions and data-type as the input.
            If second argument is not supplied then a new array is returned
            with the rounded values.

            If a second argument is supplied the result is stored there.
            The return value ``out`` is then a reference to that array.

        See Also
        --------
        rint, trunc, floor, ceil
        around : Round to given number of decimals

        Examples
        --------
        >>> import numpy as np
        >>> np.fix(3.14)
        3.0
        >>> np.fix(3)
        3
        >>> np.fix([2.1, 2.9, -2.1, -2.9])
        array([ 2.,  2., -2., -2.])

    flatnonzero(a)
        Return indices that are non-zero in the flattened version of a.

        This is equivalent to ``np.nonzero(np.ravel(a))[0]``.

        Parameters
        ----------
        a : array_like
            Input data.

        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
        --------
        >>> import numpy as np
        >>> 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])

    flip(m, axis=None)
        Reverse the order of elements in an array along the given axis.

        The shape of the array is preserved, but the elements are reordered.

        .. versionadded:: 1.12.0

        Parameters
        ----------
        m : array_like
            Input array.
        axis : None or int or tuple of ints, optional
             Axis or axes along which to flip over. The default,
             axis=None, will flip over all of the axes of the input array.
             If axis is negative it counts from the last to the first axis.

             If axis is a tuple of ints, flipping is performed on all of the axes
             specified in the tuple.

             .. versionchanged:: 1.15.0
                None and tuples of axes are supported

        Returns
        -------
        out : array_like
            A view of `m` with the entries of axis reversed.  Since a view is
            returned, this operation is done in constant time.

        See Also
        --------
        flipud : Flip an array vertically (axis=0).
        fliplr : Flip an array horizontally (axis=1).

        Notes
        -----
        flip(m, 0) is equivalent to flipud(m).

        flip(m, 1) is equivalent to fliplr(m).

        flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.

        flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all
        positions.

        flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at
        position 0 and position 1.

        Examples
        --------
        >>> import numpy as np
        >>> A = np.arange(8).reshape((2,2,2))
        >>> A
        array([[[0, 1],
                [2, 3]],
               [[4, 5],
                [6, 7]]])
        >>> np.flip(A, 0)
        array([[[4, 5],
                [6, 7]],
               [[0, 1],
                [2, 3]]])
        >>> np.flip(A, 1)
        array([[[2, 3],
                [0, 1]],
               [[6, 7],
                [4, 5]]])
        >>> np.flip(A)
        array([[[7, 6],
                [5, 4]],
               [[3, 2],
                [1, 0]]])
        >>> np.flip(A, (0, 2))
        array([[[5, 4],
                [7, 6]],
               [[1, 0],
                [3, 2]]])
        >>> rng = np.random.default_rng()
        >>> A = rng.normal(size=(3,4,5))
        >>> np.all(np.flip(A,2) == A[:,:,::-1,...])
        True

    fliplr(m)
        Reverse the order of elements along axis 1 (left/right).

        For a 2-D array, this flips the entries in each row in the left/right
        direction. Columns are preserved, but appear in a different order than
        before.

        Parameters
        ----------
        m : array_like
            Input array, must be at least 2-D.

        Returns
        -------
        f : ndarray
            A view of `m` with the columns reversed.  Since a view
            is returned, this operation is :math:`\mathcal O(1)`.

        See Also
        --------
        flipud : Flip array in the up/down direction.
        flip : Flip array in one or more dimensions.
        rot90 : Rotate array counterclockwise.

        Notes
        -----
        Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``.
        Requires the array to be at least 2-D.

        Examples
        --------
        >>> import numpy as np
        >>> A = np.diag([1.,2.,3.])
        >>> A
        array([[1.,  0.,  0.],
               [0.,  2.,  0.],
               [0.,  0.,  3.]])
        >>> np.fliplr(A)
        array([[0.,  0.,  1.],
               [0.,  2.,  0.],
               [3.,  0.,  0.]])

        >>> rng = np.random.default_rng()
        >>> A = rng.normal(size=(2,3,5))
        >>> np.all(np.fliplr(A) == A[:,::-1,...])
        True

    flipud(m)
        Reverse the order of elements along axis 0 (up/down).

        For a 2-D array, this flips the entries in each column in the up/down
        direction. Rows are preserved, but appear in a different order than before.

        Parameters
        ----------
        m : array_like
            Input array.

        Returns
        -------
        out : array_like
            A view of `m` with the rows reversed.  Since a view is
            returned, this operation is :math:`\mathcal O(1)`.

        See Also
        --------
        fliplr : Flip array in the left/right direction.
        flip : Flip array in one or more dimensions.
        rot90 : Rotate array counterclockwise.

        Notes
        -----
        Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``.
        Requires the array to be at least 1-D.

        Examples
        --------
        >>> import numpy as np
        >>> A = np.diag([1.0, 2, 3])
        >>> A
        array([[1.,  0.,  0.],
               [0.,  2.,  0.],
               [0.,  0.,  3.]])
        >>> np.flipud(A)
        array([[0.,  0.,  3.],
               [0.,  2.,  0.],
               [1.,  0.,  0.]])

        >>> rng = np.random.default_rng()
        >>> A = rng.normal(size=(2,3,5))
        >>> np.all(np.flipud(A) == A[::-1,...])
        True

        >>> np.flipud([1,2])
        array([2, 1])

    format_float_positional(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)
        Format a floating-point scalar as a decimal string in positional notation.

        Provides control over rounding, trimming and padding. Uses and assumes
        IEEE unbiased rounding. Uses the "Dragon4" algorithm.

        Parameters
        ----------
        x : python float or numpy floating scalar
            Value to format.
        precision : non-negative integer or None, optional
            Maximum number of digits to print. May be None if `unique` is
            `True`, but must be an integer if unique is `False`.
        unique : boolean, optional
            If `True`, use a digit-generation strategy which gives the shortest
            representation which uniquely identifies the floating-point number from
            other values of the same type, by judicious rounding. If `precision`
            is given fewer digits than necessary can be printed, or if `min_digits`
            is given more can be printed, in which cases the last digit is rounded
            with unbiased rounding.
            If `False`, digits are generated as if printing an infinite-precision
            value and stopping after `precision` digits, rounding the remaining
            value with unbiased rounding
        fractional : boolean, optional
            If `True`, the cutoffs of `precision` and `min_digits` refer to the
            total number of digits after the decimal point, including leading
            zeros.
            If `False`, `precision` and `min_digits` refer to the total number of
            significant digits, before or after the decimal point, ignoring leading
            zeros.
        trim : one of 'k', '.', '0', '-', optional
            Controls post-processing trimming of trailing digits, as follows:

            * 'k' : keep trailing zeros, keep decimal point (no trimming)
            * '.' : trim all trailing zeros, leave decimal point
            * '0' : trim all but the zero before the decimal point. Insert the
              zero if it is missing.
            * '-' : trim trailing zeros and any trailing decimal point
        sign : boolean, optional
            Whether to show the sign for positive values.
        pad_left : non-negative integer, optional
            Pad the left side of the string with whitespace until at least that
            many characters are to the left of the decimal point.
        pad_right : non-negative integer, optional
            Pad the right side of the string with whitespace until at least that
            many characters are to the right of the decimal point.
        min_digits : non-negative integer or None, optional
            Minimum number of digits to print. Only has an effect if `unique=True`
            in which case additional digits past those necessary to uniquely
            identify the value may be printed, rounding the last additional digit.

            .. versionadded:: 1.21.0

        Returns
        -------
        rep : string
            The string representation of the floating point value

        See Also
        --------
        format_float_scientific

        Examples
        --------
        >>> import numpy as np
        >>> np.format_float_positional(np.float32(np.pi))
        '3.1415927'
        >>> np.format_float_positional(np.float16(np.pi))
        '3.14'
        >>> np.format_float_positional(np.float16(0.3))
        '0.3'
        >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
        '0.3000488281'

    format_float_scientific(x, precision=None, unique=True, trim='k', sign=False, pad_left=None, exp_digits=None, min_digits=None)
        Format a floating-point scalar as a decimal string in scientific notation.

        Provides control over rounding, trimming and padding. Uses and assumes
        IEEE unbiased rounding. Uses the "Dragon4" algorithm.

        Parameters
        ----------
        x : python float or numpy floating scalar
            Value to format.
        precision : non-negative integer or None, optional
            Maximum number of digits to print. May be None if `unique` is
            `True`, but must be an integer if unique is `False`.
        unique : boolean, optional
            If `True`, use a digit-generation strategy which gives the shortest
            representation which uniquely identifies the floating-point number from
            other values of the same type, by judicious rounding. If `precision`
            is given fewer digits than necessary can be printed. If `min_digits`
            is given more can be printed, in which cases the last digit is rounded
            with unbiased rounding.
            If `False`, digits are generated as if printing an infinite-precision
            value and stopping after `precision` digits, rounding the remaining
            value with unbiased rounding
        trim : one of 'k', '.', '0', '-', optional
            Controls post-processing trimming of trailing digits, as follows:

            * 'k' : keep trailing zeros, keep decimal point (no trimming)
            * '.' : trim all trailing zeros, leave decimal point
            * '0' : trim all but the zero before the decimal point. Insert the
              zero if it is missing.
            * '-' : trim trailing zeros and any trailing decimal point
        sign : boolean, optional
            Whether to show the sign for positive values.
        pad_left : non-negative integer, optional
            Pad the left side of the string with whitespace until at least that
            many characters are to the left of the decimal point.
        exp_digits : non-negative integer, optional
            Pad the exponent with zeros until it contains at least this
            many digits. If omitted, the exponent will be at least 2 digits.
        min_digits : non-negative integer or None, optional
            Minimum number of digits to print. This only has an effect for
            `unique=True`. In that case more digits than necessary to uniquely
            identify the value may be printed and rounded unbiased.

            .. versionadded:: 1.21.0

        Returns
        -------
        rep : string
            The string representation of the floating point value

        See Also
        --------
        format_float_positional

        Examples
        --------
        >>> import numpy as np
        >>> np.format_float_scientific(np.float32(np.pi))
        '3.1415927e+00'
        >>> s = np.float32(1.23e24)
        >>> np.format_float_scientific(s, unique=False, precision=15)
        '1.230000071797338e+24'
        >>> np.format_float_scientific(s, exp_digits=4)
        '1.23e+0024'

    from_dlpack(...)
        from_dlpack(x, /, *, device=None, copy=None)

        Create a NumPy array from an object implementing the ``__dlpack__``
        protocol. Generally, the returned NumPy array is a read-only view
        of the input object. See [1]_ and [2]_ for more details.

        Parameters
        ----------
        x : object
            A Python object that implements the ``__dlpack__`` and
            ``__dlpack_device__`` methods.
        device : device, optional
            Device on which to place the created array. Default: ``None``.
            Must be ``"cpu"`` if passed which may allow importing an array
            that is not already CPU available.
        copy : bool, optional
            Boolean indicating whether or not to copy the input. If ``True``,
            the copy will be made. If ``False``, the function will never copy,
            and will raise ``BufferError`` in case a copy is deemed necessary.
            Passing it requests a copy from the exporter who may or may not
            implement the capability.
            If ``None``, the function will reuse the existing memory buffer if
            possible and copy otherwise. Default: ``None``.


        Returns
        -------
        out : ndarray

        References
        ----------
        .. [1] Array API documentation,
           https://data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-for-data-interchange-with-dlpack

        .. [2] Python specification for DLPack,
           https://dmlc.github.io/dlpack/latest/python_spec.html

        Examples
        --------
        >>> import torch  # doctest: +SKIP
        >>> x = torch.arange(10)  # doctest: +SKIP
        >>> # create a view of the torch tensor "x" in NumPy
        >>> y = np.from_dlpack(x)  # doctest: +SKIP

    frombuffer(...)
        frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)

        Interpret a buffer as a 1-dimensional array.

        Parameters
        ----------
        buffer : buffer_like
            An object that exposes the buffer interface.
        dtype : data-type, optional
            Data-type of the returned array; default: float.
        count : int, optional
            Number of items to read. ``-1`` means all data in the buffer.
        offset : int, optional
            Start reading the buffer from this offset (in bytes); default: 0.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray

        See also
        --------
        ndarray.tobytes
            Inverse of this operation, construct Python bytes from the raw data
            bytes in the array.

        Notes
        -----
        If the buffer has data that is not in machine byte-order, this should
        be specified as part of the data-type, e.g.::

          >>> dt = np.dtype(int)
          >>> dt = dt.newbyteorder('>')
          >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP

        The data of the resulting array will not be byteswapped, but will be
        interpreted correctly.

        This function creates a view into the original object.  This should be safe
        in general, but it may make sense to copy the result when the original
        object is mutable or untrusted.

        Examples
        --------
        >>> import numpy as np
        >>> s = b'hello world'
        >>> np.frombuffer(s, dtype='S1', count=5, offset=6)
        array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')

        >>> np.frombuffer(b'\x01\x02', dtype=np.uint8)
        array([1, 2], dtype=uint8)
        >>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)
        array([1, 2, 3], dtype=uint8)

    fromfile(...)
        fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None)

        Construct an array from data in a text or binary file.

        A highly efficient way of reading binary data with a known data-type,
        as well as parsing simply formatted text files.  Data written using the
        `tofile` method can be read using this function.

        Parameters
        ----------
        file : file or str or Path
            Open file object or filename.

            .. versionchanged:: 1.17.0
                `pathlib.Path` objects are now accepted.

        dtype : data-type
            Data type of the returned array.
            For binary files, it is used to determine the size and byte-order
            of the items in the file.
            Most builtin numeric types are supported and extension types may be supported.

            .. versionadded:: 1.18.0
                Complex dtypes.

        count : int
            Number of items to read. ``-1`` means all items (i.e., the complete
            file).
        sep : str
            Separator between items if file is a text file.
            Empty ("") separator means the file should be treated as binary.
            Spaces (" ") in the separator match zero or more whitespace characters.
            A separator consisting only of spaces must match at least one
            whitespace.
        offset : int
            The offset (in bytes) from the file's current position. Defaults to 0.
            Only permitted for binary files.

            .. versionadded:: 1.17.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        See also
        --------
        load, save
        ndarray.tofile
        loadtxt : More flexible way of loading data from a text file.

        Notes
        -----
        Do not rely on the combination of `tofile` and `fromfile` for
        data storage, as the binary files generated are not platform
        independent.  In particular, no byte-order or data-type information is
        saved.  Data can be stored in the platform independent ``.npy`` format
        using `save` and `load` instead.

        Examples
        --------
        Construct an ndarray:

        >>> import numpy as np
        >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),
        ...                ('temp', float)])
        >>> x = np.zeros((1,), dtype=dt)
        >>> x['time']['min'] = 10; x['temp'] = 98.25
        >>> x
        array([((10, 0), 98.25)],
              dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

        Save the raw data to disk:

        >>> import tempfile
        >>> fname = tempfile.mkstemp()[1]
        >>> x.tofile(fname)

        Read the raw data from disk:

        >>> np.fromfile(fname, dtype=dt)
        array([((10, 0), 98.25)],
              dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

        The recommended way to store and load data:

        >>> np.save(fname, x)
        >>> np.load(fname + '.npy')
        array([((10, 0), 98.25)],
              dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

    fromfunction(function, shape, *, dtype=<class 'float'>, like=None, **kwargs)
        Construct an array by executing a function over each coordinate.

        The resulting array therefore has a value ``fn(x, y, z)`` at
        coordinate ``(x, y, z)``.

        Parameters
        ----------
        function : callable
            The function is called with N parameters, where N is the rank of
            `shape`.  Each parameter represents the coordinates of the array
            varying along a specific axis.  For example, if `shape`
            were ``(2, 2)``, then the parameters would be
            ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
        shape : (N,) tuple of ints
            Shape of the output array, which also determines the shape of
            the coordinate arrays passed to `function`.
        dtype : data-type, optional
            Data-type of the coordinate arrays passed to `function`.
            By default, `dtype` is float.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        fromfunction : any
            The result of the call to `function` is passed back directly.
            Therefore the shape of `fromfunction` is completely determined by
            `function`.  If `function` returns a scalar value, the shape of
            `fromfunction` would not match the `shape` parameter.

        See Also
        --------
        indices, meshgrid

        Notes
        -----
        Keywords other than `dtype` and `like` are passed to `function`.

        Examples
        --------
        >>> import numpy as np
        >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float)
        array([[0., 0.],
               [1., 1.]])

        >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float)
        array([[0., 1.],
               [0., 1.]])

        >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
        array([[ True, False, False],
               [False,  True, False],
               [False, False,  True]])

        >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
        array([[0, 1, 2],
               [1, 2, 3],
               [2, 3, 4]])

    fromiter(...)
        fromiter(iter, dtype, count=-1, *, like=None)

        Create a new 1-dimensional array from an iterable object.

        Parameters
        ----------
        iter : iterable object
            An iterable object providing data for the array.
        dtype : data-type
            The data-type of the returned array.

            .. versionchanged:: 1.23
                Object and subarray dtypes are now supported (note that the final
                result is not 1-D for a subarray dtype).

        count : int, optional
            The number of items to read from *iterable*.  The default is -1,
            which means all data is read.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            The output array.

        Notes
        -----
        Specify `count` to improve performance.  It allows ``fromiter`` to
        pre-allocate the output array, instead of resizing it on demand.

        Examples
        --------
        >>> import numpy as np
        >>> iterable = (x*x for x in range(5))
        >>> np.fromiter(iterable, float)
        array([  0.,   1.,   4.,   9.,  16.])

        A carefully constructed subarray dtype will lead to higher dimensional
        results:

        >>> iterable = ((x+1, x+2) for x in range(5))
        >>> np.fromiter(iterable, dtype=np.dtype((int, 2)))
        array([[1, 2],
               [2, 3],
               [3, 4],
               [4, 5],
               [5, 6]])

    frompyfunc(...)
        frompyfunc(func, /, nin, nout, *[, identity])

        Takes an arbitrary Python function and returns a NumPy ufunc.

        Can be used, for example, to add broadcasting to a built-in Python
        function (see Examples section).

        Parameters
        ----------
        func : Python function object
            An arbitrary Python function.
        nin : int
            The number of input arguments.
        nout : int
            The number of objects returned by `func`.
        identity : object, optional
            The value to use for the `~numpy.ufunc.identity` attribute of the resulting
            object. If specified, this is equivalent to setting the underlying
            C ``identity`` field to ``PyUFunc_IdentityValue``.
            If omitted, the identity is set to ``PyUFunc_None``. Note that this is
            _not_ equivalent to setting the identity to ``None``, which implies the
            operation is reorderable.

        Returns
        -------
        out : ufunc
            Returns a NumPy universal function (``ufunc``) object.

        See Also
        --------
        vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.

        Notes
        -----
        The returned ufunc always returns PyObject arrays.

        Examples
        --------
        Use frompyfunc to add broadcasting to the Python function ``oct``:

        >>> import numpy as np
        >>> oct_array = np.frompyfunc(oct, 1, 1)
        >>> oct_array(np.array((10, 30, 100)))
        array(['0o12', '0o36', '0o144'], dtype=object)
        >>> np.array((oct(10), oct(30), oct(100))) # for comparison
        array(['0o12', '0o36', '0o144'], dtype='<U5')

    fromregex(file, regexp, dtype, encoding=None)
        Construct an array from a text file, using regular expression parsing.

        The returned array is always a structured array, and is constructed from
        all matches of the regular expression in the file. Groups in the regular
        expression are converted to fields of the structured array.

        Parameters
        ----------
        file : file, str, or pathlib.Path
            Filename or file object to read.

            .. versionchanged:: 1.22.0
                Now accepts `os.PathLike` implementations.
        regexp : str or regexp
            Regular expression used to parse the file.
            Groups in the regular expression correspond to fields in the dtype.
        dtype : dtype or list of dtypes
            Dtype for the structured array; must be a structured datatype.
        encoding : str, optional
            Encoding used to decode the inputfile. Does not apply to input streams.

            .. versionadded:: 1.14.0

        Returns
        -------
        output : ndarray
            The output array, containing the part of the content of `file` that
            was matched by `regexp`. `output` is always a structured array.

        Raises
        ------
        TypeError
            When `dtype` is not a valid dtype for a structured array.

        See Also
        --------
        fromstring, loadtxt

        Notes
        -----
        Dtypes for structured arrays can be specified in several forms, but all
        forms specify at least the data type and field name. For details see
        `basics.rec`.

        Examples
        --------
        >>> import numpy as np
        >>> from io import StringIO
        >>> text = StringIO("1312 foo\n1534  bar\n444   qux")

        >>> regexp = r"(\d+)\s+(...)"  # match [digits, whitespace, anything]
        >>> output = np.fromregex(text, regexp,
        ...                       [('num', np.int64), ('key', 'S3')])
        >>> output
        array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
              dtype=[('num', '<i8'), ('key', 'S3')])
        >>> output['num']
        array([1312, 1534,  444])

    fromstring(...)
        fromstring(string, dtype=float, count=-1, *, sep, like=None)

        A new 1-D array initialized from text data in a string.

        Parameters
        ----------
        string : str
            A string containing the data.
        dtype : data-type, optional
            The data type of the array; default: float.  For binary input data,
            the data must be in exactly this format. Most builtin numeric types are
            supported and extension types may be supported.

            .. versionadded:: 1.18.0
                Complex dtypes.

        count : int, optional
            Read this number of `dtype` elements from the data.  If this is
            negative (the default), the count will be determined from the
            length of the data.
        sep : str, optional
            The string separating numbers in the data; extra whitespace between
            elements is also ignored.

            .. deprecated:: 1.14
                Passing ``sep=''``, the default, is deprecated since it will
                trigger the deprecated binary mode of this function. This mode
                interprets `string` as binary bytes, rather than ASCII text with
                decimal numbers, an operation which is better spelt
                ``frombuffer(string, dtype, count)``. If `string` contains unicode
                text, the binary mode of `fromstring` will first encode it into
                bytes using utf-8, which will not produce sane results.

        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        arr : ndarray
            The constructed array.

        Raises
        ------
        ValueError
            If the string is not the correct size to satisfy the requested
            `dtype` and `count`.

        See Also
        --------
        frombuffer, fromfile, fromiter

        Examples
        --------
        >>> import numpy as np
        >>> np.fromstring('1 2', dtype=int, sep=' ')
        array([1, 2])
        >>> np.fromstring('1, 2', dtype=int, sep=',')
        array([1, 2])

    full(shape, fill_value, dtype=None, order='C', *, device=None, like=None)
        Return a new array of given shape and type, filled with `fill_value`.

        Parameters
        ----------
        shape : int or sequence of ints
            Shape of the new array, e.g., ``(2, 3)`` or ``2``.
        fill_value : scalar or array_like
            Fill value.
        dtype : data-type, optional
            The desired data-type for the array  The default, None, means
             ``np.array(fill_value).dtype``.
        order : {'C', 'F'}, optional
            Whether to store multidimensional data in C- or Fortran-contiguous
            (row- or column-wise) order in memory.
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Array of `fill_value` with the given shape, dtype, and order.

        See Also
        --------
        full_like : Return a new array with shape of input filled with value.
        empty : Return a new uninitialized array.
        ones : Return a new array setting values to one.
        zeros : Return a new array setting values to zero.

        Examples
        --------
        >>> import numpy as np
        >>> np.full((2, 2), np.inf)
        array([[inf, inf],
               [inf, inf]])
        >>> np.full((2, 2), 10)
        array([[10, 10],
               [10, 10]])

        >>> np.full((2, 2), [1, 2])
        array([[1, 2],
               [1, 2]])

    full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None, *, device=None)
        Return a full array 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.
        fill_value : array_like
            Fill value.
        dtype : data-type, optional
            Overrides the data type of the result.
        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.
        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.
        shape : int or sequence of ints, optional.
            Overrides the shape of the result. If order='K' and the number of
            dimensions is unchanged, will try to keep order, otherwise,
            order='C' is implied.

            .. versionadded:: 1.17.0
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0

        Returns
        -------
        out : ndarray
            Array of `fill_value` with the same shape and type as `a`.

        See Also
        --------
        empty_like : Return an empty array with shape and type of input.
        ones_like : Return an array of ones with shape and type of input.
        zeros_like : Return an array of zeros with shape and type of input.
        full : Return a new array of given shape filled with value.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(6, dtype=int)
        >>> np.full_like(x, 1)
        array([1, 1, 1, 1, 1, 1])
        >>> np.full_like(x, 0.1)
        array([0, 0, 0, 0, 0, 0])
        >>> np.full_like(x, 0.1, dtype=np.double)
        array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
        >>> np.full_like(x, np.nan, dtype=np.double)
        array([nan, nan, nan, nan, nan, nan])

        >>> y = np.arange(6, dtype=np.double)
        >>> np.full_like(y, 0.1)
        array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

        >>> y = np.zeros([2, 2, 3], dtype=int)
        >>> np.full_like(y, [0, 0, 255])
        array([[[  0,   0, 255],
                [  0,   0, 255]],
               [[  0,   0, 255],
                [  0,   0, 255]]])

    genfromtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=" !#$%&'()*+,-./:;<=>?@[\\]^{|}~", replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding=None, *, ndmin=0, like=None)
        Load data from a text file, with missing values handled as specified.

        Each line past the first `skip_header` lines is split at the `delimiter`
        character, and characters following the `comments` character are discarded.

        Parameters
        ----------
        fname : file, str, pathlib.Path, list of str, generator
            File, filename, list, or generator to read.  If the filename
            extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
            that generators must return bytes or strings. The strings
            in a list or produced by a generator are treated as lines.
        dtype : dtype, optional
            Data type of the resulting array.
            If None, the dtypes will be determined by the contents of each
            column, individually.
        comments : str, optional
            The character used to indicate the start of a comment.
            All the characters occurring on a line after a comment are discarded.
        delimiter : str, int, or sequence, optional
            The string used to separate values.  By default, any consecutive
            whitespaces act as delimiter.  An integer or sequence of integers
            can also be provided as width(s) of each field.
        skiprows : int, optional
            `skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
        skip_header : int, optional
            The number of lines to skip at the beginning of the file.
        skip_footer : int, optional
            The number of lines to skip at the end of the file.
        converters : variable, optional
            The set of functions that convert the data of a column to a value.
            The converters can also be used to provide a default value
            for missing data: ``converters = {3: lambda s: float(s or 0)}``.
        missing : variable, optional
            `missing` was removed in numpy 1.10. Please use `missing_values`
            instead.
        missing_values : variable, optional
            The set of strings corresponding to missing data.
        filling_values : variable, optional
            The set of values to be used as default when the data are missing.
        usecols : sequence, optional
            Which columns to read, with 0 being the first.  For example,
            ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
        names : {None, True, str, sequence}, optional
            If `names` is True, the field names are read from the first line after
            the first `skip_header` lines. This line can optionally be preceded
            by a comment delimiter. Any content before the comment delimiter is
            discarded. If `names` is a sequence or a single-string of
            comma-separated names, the names will be used to define the field
            names in a structured dtype. If `names` is None, the names of the
            dtype fields will be used, if any.
        excludelist : sequence, optional
            A list of names to exclude. This list is appended to the default list
            ['return','file','print']. Excluded names are appended with an
            underscore: for example, `file` would become `file_`.
        deletechars : str, optional
            A string combining invalid characters that must be deleted from the
            names.
        defaultfmt : str, optional
            A format used to define default field names, such as "f%i" or "f_%02i".
        autostrip : bool, optional
            Whether to automatically strip white spaces from the variables.
        replace_space : char, optional
            Character(s) used in replacement of white spaces in the variable
            names. By default, use a '_'.
        case_sensitive : {True, False, 'upper', 'lower'}, optional
            If True, field names are case sensitive.
            If False or 'upper', field names are converted to upper case.
            If 'lower', field names are converted to lower case.
        unpack : bool, optional
            If True, the returned array is transposed, so that arguments may be
            unpacked using ``x, y, z = genfromtxt(...)``.  When used with a
            structured data-type, arrays are returned for each field.
            Default is False.
        usemask : bool, optional
            If True, return a masked array.
            If False, return a regular array.
        loose : bool, optional
            If True, do not raise errors for invalid values.
        invalid_raise : bool, optional
            If True, an exception is raised if an inconsistency is detected in the
            number of columns.
            If False, a warning is emitted and the offending lines are skipped.
        max_rows : int,  optional
            The maximum number of rows to read. Must not be used with skip_footer
            at the same time.  If given, the value must be at least 1. Default is
            to read the entire file.

            .. versionadded:: 1.10.0
        encoding : str, optional
            Encoding used to decode the inputfile. Does not apply when `fname`
            is a file object. The special value 'bytes' enables backward
            compatibility workarounds that ensure that you receive byte arrays
            when possible and passes latin1 encoded strings to converters.
            Override this value to receive unicode arrays and pass strings
            as input to converters.  If set to None the system default is used.
            The default value is 'bytes'.

            .. versionadded:: 1.14.0
            .. versionchanged:: 2.0
                Before NumPy 2, the default was ``'bytes'`` for Python 2
                compatibility. The default is now ``None``.

        ndmin : int, optional
            Same parameter as `loadtxt`

            .. versionadded:: 1.23.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Data read from the text file. If `usemask` is True, this is a
            masked array.

        See Also
        --------
        numpy.loadtxt : equivalent function when no data is missing.

        Notes
        -----
        * When spaces are used as delimiters, or when no delimiter has been given
          as input, there should not be any missing data between two fields.
        * When variables are named (either by a flexible dtype or with a `names`
          sequence), there must not be any header in the file (else a ValueError
          exception is raised).
        * Individual values are not stripped of spaces by default.
          When using a custom converter, make sure the function does remove spaces.
        * Custom converters may receive unexpected values due to dtype
          discovery.

        References
        ----------
        .. [1] NumPy User Guide, section `I/O with NumPy
               <https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.

        Examples
        --------
        >>> from io import StringIO
        >>> import numpy as np

        Comma delimited file with mixed dtype

        >>> s = StringIO("1,1.3,abcde")
        >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
        ... ('mystring','S5')], delimiter=",")
        >>> data
        array((1, 1.3, b'abcde'),
              dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

        Using dtype = None

        >>> _ = s.seek(0) # needed for StringIO example only
        >>> data = np.genfromtxt(s, dtype=None,
        ... names = ['myint','myfloat','mystring'], delimiter=",")
        >>> data
        array((1, 1.3, 'abcde'),
              dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '<U5')])

        Specifying dtype and names

        >>> _ = s.seek(0)
        >>> data = np.genfromtxt(s, dtype="i8,f8,S5",
        ... names=['myint','myfloat','mystring'], delimiter=",")
        >>> data
        array((1, 1.3, b'abcde'),
              dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

        An example with fixed-width columns

        >>> s = StringIO("11.3abcde")
        >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
        ...     delimiter=[1,3,5])
        >>> data
        array((1, 1.3, 'abcde'),
              dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', '<U5')])

        An example to show comments

        >>> f = StringIO('''
        ... text,# of chars
        ... hello world,11
        ... numpy,5''')
        >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
        array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
          dtype=[('f0', 'S12'), ('f1', 'S12')])

    geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)
        Return numbers spaced evenly on a log scale (a geometric progression).

        This is similar to `logspace`, but with endpoints specified directly.
        Each output sample is a constant multiple of the previous.

        .. versionchanged:: 1.16.0
            Non-scalar `start` and `stop` are now supported.

        Parameters
        ----------
        start : array_like
            The starting value of the sequence.
        stop : array_like
            The final value of the sequence, unless `endpoint` is False.
            In that case, ``num + 1`` values are spaced over the
            interval in log-space, of which all but the last (a sequence of
            length `num`) are returned.
        num : integer, optional
            Number of samples to generate.  Default is 50.
        endpoint : boolean, optional
            If true, `stop` is the last sample. Otherwise, it is not included.
            Default is True.
        dtype : dtype
            The type of the output array.  If `dtype` is not given, the data type
            is inferred from `start` and `stop`. The inferred dtype will never be
            an integer; `float` is chosen even if the arguments would produce an
            array of integers.
        axis : int, optional
            The axis in the result to store the samples.  Relevant only if start
            or stop are array-like.  By default (0), the samples will be along a
            new axis inserted at the beginning. Use -1 to get an axis at the end.

            .. versionadded:: 1.16.0

        Returns
        -------
        samples : ndarray
            `num` samples, equally spaced on a log scale.

        See Also
        --------
        logspace : Similar to geomspace, but with endpoints specified using log
                   and base.
        linspace : Similar to geomspace, but with arithmetic instead of geometric
                   progression.
        arange : Similar to linspace, with the step size specified instead of the
                 number of samples.
        :ref:`how-to-partition`

        Notes
        -----
        If the inputs or dtype are complex, the output will follow a logarithmic
        spiral in the complex plane.  (There are an infinite number of spirals
        passing through two points; the output will follow the shortest such path.)

        Examples
        --------
        >>> import numpy as np
        >>> np.geomspace(1, 1000, num=4)
        array([    1.,    10.,   100.,  1000.])
        >>> np.geomspace(1, 1000, num=3, endpoint=False)
        array([   1.,   10.,  100.])
        >>> np.geomspace(1, 1000, num=4, endpoint=False)
        array([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])
        >>> np.geomspace(1, 256, num=9)
        array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])

        Note that the above may not produce exact integers:

        >>> np.geomspace(1, 256, num=9, dtype=int)
        array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
        >>> np.around(np.geomspace(1, 256, num=9)).astype(int)
        array([  1,   2,   4,   8,  16,  32,  64, 128, 256])

        Negative, decreasing, and complex inputs are allowed:

        >>> np.geomspace(1000, 1, num=4)
        array([1000.,  100.,   10.,    1.])
        >>> np.geomspace(-1000, -1, num=4)
        array([-1000.,  -100.,   -10.,    -1.])
        >>> np.geomspace(1j, 1000j, num=4)  # Straight line
        array([0.   +1.j, 0.  +10.j, 0. +100.j, 0.+1000.j])
        >>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
        array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
                6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
                1.00000000e+00+0.00000000e+00j])

        Graphical illustration of `endpoint` parameter:

        >>> import matplotlib.pyplot as plt
        >>> N = 10
        >>> y = np.zeros(N)
        >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.axis([0.5, 2000, 0, 3])
        [0.5, 2000, 0, 3]
        >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
        >>> plt.show()

    get_include()
        Return the directory that contains the NumPy \*.h header files.

        Extension modules that need to compile against NumPy may need to use this
        function to locate the appropriate include directory.

        Notes
        -----
        When using ``setuptools``, for example in ``setup.py``::

            import numpy as np
            ...
            Extension('extension_name', ...
                      include_dirs=[np.get_include()])
            ...

        Note that a CLI tool ``numpy-config`` was introduced in NumPy 2.0, using
        that is likely preferred for build systems other than ``setuptools``::

            $ numpy-config --cflags
            -I/path/to/site-packages/numpy/_core/include

            # Or rely on pkg-config:
            $ export PKG_CONFIG_PATH=$(numpy-config --pkgconfigdir)
            $ pkg-config --cflags
            -I/path/to/site-packages/numpy/_core/include

        Examples
        --------
        >>> np.get_include()
        '.../site-packages/numpy/core/include'  # may vary

    get_printoptions()
        Return the current print options.

        Returns
        -------
        print_opts : dict
            Dictionary of current print options with keys

            - precision : int
            - threshold : int
            - edgeitems : int
            - linewidth : int
            - suppress : bool
            - nanstr : str
            - infstr : str
            - sign : str
            - formatter : dict of callables
            - floatmode : str
            - legacy : str or False

            For a full description of these options, see `set_printoptions`.

        See Also
        --------
        set_printoptions, printoptions

        Examples
        --------
        >>> import numpy as np

        >>> np.get_printoptions()
        {'edgeitems': 3, 'threshold': 1000, ..., 'override_repr': None}

        >>> np.get_printoptions()['linewidth']
        75
        >>> np.set_printoptions(linewidth=100)
        >>> np.get_printoptions()['linewidth']
        100

    getbufsize()
        Return the size of the buffer used in ufuncs.

        Returns
        -------
        getbufsize : int
            Size of ufunc buffer in bytes.

        Examples
        --------
        >>> import numpy as np
        >>> np.getbufsize()
        8192

    geterr()
        Get the current way of handling floating-point errors.

        Returns
        -------
        res : dict
            A dictionary with keys "divide", "over", "under", and "invalid",
            whose values are from the strings "ignore", "print", "log", "warn",
            "raise", and "call". The keys represent possible floating-point
            exceptions, and the values define how these exceptions are handled.

        See Also
        --------
        geterrcall, seterr, seterrcall

        Notes
        -----
        For complete documentation of the types of floating-point exceptions and
        treatment options, see `seterr`.

        Examples
        --------
        >>> import numpy as np
        >>> np.geterr()
        {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}
        >>> np.arange(3.) / np.arange(3.)  # doctest: +SKIP
        array([nan,  1.,  1.])
        RuntimeWarning: invalid value encountered in divide

        >>> oldsettings = np.seterr(all='warn', invalid='raise')
        >>> np.geterr()
        {'divide': 'warn', 'over': 'warn', 'under': 'warn', 'invalid': 'raise'}
        >>> np.arange(3.) / np.arange(3.)
        Traceback (most recent call last):
          ...
        FloatingPointError: invalid value encountered in divide
        >>> oldsettings = np.seterr(**oldsettings)  # restore original

    geterrcall()
        Return the current callback function used on floating-point errors.

        When the error handling for a floating-point error (one of "divide",
        "over", "under", or "invalid") is set to 'call' or 'log', the function
        that is called or the log instance that is written to is returned by
        `geterrcall`. This function or log instance has been set with
        `seterrcall`.

        Returns
        -------
        errobj : callable, log instance or None
            The current error handler. If no handler was set through `seterrcall`,
            ``None`` is returned.

        See Also
        --------
        seterrcall, seterr, geterr

        Notes
        -----
        For complete documentation of the types of floating-point exceptions and
        treatment options, see `seterr`.

        Examples
        --------
        >>> import numpy as np
        >>> np.geterrcall()  # we did not yet set a handler, returns None

        >>> orig_settings = np.seterr(all='call')
        >>> def err_handler(type, flag):
        ...     print("Floating point error (%s), with flag %s" % (type, flag))
        >>> old_handler = np.seterrcall(err_handler)
        >>> np.array([1, 2, 3]) / 0.0
        Floating point error (divide by zero), with flag 1
        array([inf, inf, inf])

        >>> cur_handler = np.geterrcall()
        >>> cur_handler is err_handler
        True
        >>> old_settings = np.seterr(**orig_settings)  # restore original
        >>> old_handler = np.seterrcall(None)  # restore original

    gradient(f, *varargs, axis=None, edge_order=1)
        Return the gradient of an N-dimensional array.

        The gradient is computed using second order accurate central differences
        in the interior points and either first or second order accurate one-sides
        (forward or backwards) differences at the boundaries.
        The returned gradient hence has the same shape as the input array.

        Parameters
        ----------
        f : array_like
            An N-dimensional array containing samples of a scalar function.
        varargs : list of scalar or array, optional
            Spacing between f values. Default unitary spacing for all dimensions.
            Spacing can be specified using:

            1. single scalar to specify a sample distance for all dimensions.
            2. N scalars to specify a constant sample distance for each dimension.
               i.e. `dx`, `dy`, `dz`, ...
            3. N arrays to specify the coordinates of the values along each
               dimension of F. The length of the array must match the size of
               the corresponding dimension
            4. Any combination of N scalars/arrays with the meaning of 2. and 3.

            If `axis` is given, the number of varargs must equal the number of axes.
            Default: 1. (see Examples below).

        edge_order : {1, 2}, optional
            Gradient is calculated using N-th order accurate differences
            at the boundaries. Default: 1.

            .. versionadded:: 1.9.1

        axis : None or int or tuple of ints, optional
            Gradient is calculated only along the given axis or axes
            The default (axis = None) is to calculate the gradient for all the axes
            of the input array. axis may be negative, in which case it counts from
            the last to the first axis.

            .. versionadded:: 1.11.0

        Returns
        -------
        gradient : ndarray or tuple of ndarray
            A tuple of ndarrays (or a single ndarray if there is only one
            dimension) corresponding to the derivatives of f with respect
            to each dimension. Each derivative has the same shape as f.

        Examples
        --------
        >>> import numpy as np
        >>> f = np.array([1, 2, 4, 7, 11, 16])
        >>> np.gradient(f)
        array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])
        >>> np.gradient(f, 2)
        array([0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])

        Spacing can be also specified with an array that represents the coordinates
        of the values F along the dimensions.
        For instance a uniform spacing:

        >>> x = np.arange(f.size)
        >>> np.gradient(f, x)
        array([1. ,  1.5,  2.5,  3.5,  4.5,  5. ])

        Or a non uniform one:

        >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.])
        >>> np.gradient(f, x)
        array([1. ,  3. ,  3.5,  6.7,  6.9,  2.5])

        For two dimensional arrays, the return will be two arrays ordered by
        axis. In this example the first array stands for the gradient in
        rows and the second one in columns direction:

        >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]))
        (array([[ 2.,  2., -1.],
                [ 2.,  2., -1.]]),
         array([[1. , 2.5, 4. ],
                [1. , 1. , 1. ]]))

        In this example the spacing is also specified:
        uniform for axis=0 and non uniform for axis=1

        >>> dx = 2.
        >>> y = [1., 1.5, 3.5]
        >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]), dx, y)
        (array([[ 1. ,  1. , -0.5],
                [ 1. ,  1. , -0.5]]),
         array([[2. , 2. , 2. ],
                [2. , 1.7, 0.5]]))

        It is possible to specify how boundaries are treated using `edge_order`

        >>> x = np.array([0, 1, 2, 3, 4])
        >>> f = x**2
        >>> np.gradient(f, edge_order=1)
        array([1.,  2.,  4.,  6.,  7.])
        >>> np.gradient(f, edge_order=2)
        array([0., 2., 4., 6., 8.])

        The `axis` keyword can be used to specify a subset of axes of which the
        gradient is calculated

        >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]), axis=0)
        array([[ 2.,  2., -1.],
               [ 2.,  2., -1.]])

        The `varargs` argument defines the spacing between sample points in the
        input array. It can take two forms:

        1. An array, specifying coordinates, which may be unevenly spaced:

        >>> x = np.array([0., 2., 3., 6., 8.])
        >>> y = x ** 2
        >>> np.gradient(y, x, edge_order=2)
        array([ 0.,  4.,  6., 12., 16.])

        2. A scalar, representing the fixed sample distance:

        >>> dx = 2
        >>> x = np.array([0., 2., 4., 6., 8.])
        >>> y = x ** 2
        >>> np.gradient(y, dx, edge_order=2)
        array([ 0.,  4.,  8., 12., 16.])

        It's possible to provide different data for spacing along each dimension.
        The number of arguments must match the number of dimensions in the input
        data.

        >>> dx = 2
        >>> dy = 3
        >>> x = np.arange(0, 6, dx)
        >>> y = np.arange(0, 9, dy)
        >>> xs, ys = np.meshgrid(x, y)
        >>> zs = xs + 2 * ys
        >>> np.gradient(zs, dy, dx)  # Passing two scalars
        (array([[2., 2., 2.],
                [2., 2., 2.],
                [2., 2., 2.]]),
         array([[1., 1., 1.],
                [1., 1., 1.],
                [1., 1., 1.]]))

        Mixing scalars and arrays is also allowed:

        >>> np.gradient(zs, y, dx)  # Passing one array and one scalar
        (array([[2., 2., 2.],
                [2., 2., 2.],
                [2., 2., 2.]]),
         array([[1., 1., 1.],
                [1., 1., 1.],
                [1., 1., 1.]]))

        Notes
        -----
        Assuming that :math:`f\in C^{3}` (i.e., :math:`f` has at least 3 continuous
        derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we
        minimize the "consistency error" :math:`\eta_{i}` between the true gradient
        and its estimate from a linear combination of the neighboring grid-points:

        .. math::

            \eta_{i} = f_{i}^{\left(1\right)} -
                        \left[ \alpha f\left(x_{i}\right) +
                                \beta f\left(x_{i} + h_{d}\right) +
                                \gamma f\left(x_{i}-h_{s}\right)
                        \right]

        By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})`
        with their Taylor series expansion, this translates into solving
        the following the linear system:

        .. math::

            \left\{
                \begin{array}{r}
                    \alpha+\beta+\gamma=0 \\
                    \beta h_{d}-\gamma h_{s}=1 \\
                    \beta h_{d}^{2}+\gamma h_{s}^{2}=0
                \end{array}
            \right.

        The resulting approximation of :math:`f_{i}^{(1)}` is the following:

        .. math::

            \hat f_{i}^{(1)} =
                \frac{
                    h_{s}^{2}f\left(x_{i} + h_{d}\right)
                    + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right)
                    - h_{d}^{2}f\left(x_{i}-h_{s}\right)}
                    { h_{s}h_{d}\left(h_{d} + h_{s}\right)}
                + \mathcal{O}\left(\frac{h_{d}h_{s}^{2}
                                    + h_{s}h_{d}^{2}}{h_{d}
                                    + h_{s}}\right)

        It is worth noting that if :math:`h_{s}=h_{d}`
        (i.e., data are evenly spaced)
        we find the standard second order approximation:

        .. math::

            \hat f_{i}^{(1)}=
                \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h}
                + \mathcal{O}\left(h^{2}\right)

        With a similar procedure the forward/backward approximations used for
        boundaries can be derived.

        References
        ----------
        .. [1]  Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics
                (Texts in Applied Mathematics). New York: Springer.
        .. [2]  Durran D. R. (1999) Numerical Methods for Wave Equations
                in Geophysical Fluid Dynamics. New York: Springer.
        .. [3]  Fornberg B. (1988) Generation of Finite Difference Formulas on
                Arbitrarily Spaced Grids,
                Mathematics of Computation 51, no. 184 : 699-706.
                `PDF <https://www.ams.org/journals/mcom/1988-51-184/
                S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_.

    hamming(M)
        Return the Hamming window.

        The Hamming window is a taper formed by using a weighted cosine.

        Parameters
        ----------
        M : int
            Number of points in the output window. If zero or less, an
            empty array is returned.

        Returns
        -------
        out : ndarray
            The window, with the maximum value normalized to one (the value
            one appears only if the number of samples is odd).

        See Also
        --------
        bartlett, blackman, hanning, kaiser

        Notes
        -----
        The Hamming window is defined as

        .. math::  w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right)
                   \qquad 0 \leq n \leq M-1

        The Hamming was named for R. W. Hamming, an associate of J. W. Tukey
        and is described in Blackman and Tukey. It was recommended for
        smoothing the truncated autocovariance function in the time domain.
        Most references to the Hamming window come from the signal processing
        literature, where it is used as one of many windowing functions for
        smoothing values.  It is also known as an apodization (which means
        "removing the foot", i.e. smoothing discontinuities at the beginning
        and end of the sampled signal) or tapering function.

        References
        ----------
        .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
               spectra, Dover Publications, New York.
        .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The
               University of Alberta Press, 1975, pp. 109-110.
        .. [3] Wikipedia, "Window function",
               https://en.wikipedia.org/wiki/Window_function
        .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
               "Numerical Recipes", Cambridge University Press, 1986, page 425.

        Examples
        --------
        >>> import numpy as np
        >>> np.hamming(12)
        array([ 0.08      ,  0.15302337,  0.34890909,  0.60546483,  0.84123594, # may vary
                0.98136677,  0.98136677,  0.84123594,  0.60546483,  0.34890909,
                0.15302337,  0.08      ])

        Plot the window and the frequency response.

        .. plot::
            :include-source:

            import matplotlib.pyplot as plt
            from numpy.fft import fft, fftshift
            window = np.hamming(51)
            plt.plot(window)
            plt.title("Hamming window")
            plt.ylabel("Amplitude")
            plt.xlabel("Sample")
            plt.show()

            plt.figure()
            A = fft(window, 2048) / 25.5
            mag = np.abs(fftshift(A))
            freq = np.linspace(-0.5, 0.5, len(A))
            response = 20 * np.log10(mag)
            response = np.clip(response, -100, 100)
            plt.plot(freq, response)
            plt.title("Frequency response of Hamming window")
            plt.ylabel("Magnitude [dB]")
            plt.xlabel("Normalized frequency [cycles per sample]")
            plt.axis('tight')
            plt.show()

    hanning(M)
        Return the Hanning window.

        The Hanning window is a taper formed by using a weighted cosine.

        Parameters
        ----------
        M : int
            Number of points in the output window. If zero or less, an
            empty array is returned.

        Returns
        -------
        out : ndarray, shape(M,)
            The window, with the maximum value normalized to one (the value
            one appears only if `M` is odd).

        See Also
        --------
        bartlett, blackman, hamming, kaiser

        Notes
        -----
        The Hanning window is defined as

        .. math::  w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right)
                   \qquad 0 \leq n \leq M-1

        The Hanning was named for Julius von Hann, an Austrian meteorologist.
        It is also known as the Cosine Bell. Some authors prefer that it be
        called a Hann window, to help avoid confusion with the very similar
        Hamming window.

        Most references to the Hanning window come from the signal processing
        literature, where it is used as one of many windowing functions for
        smoothing values.  It is also known as an apodization (which means
        "removing the foot", i.e. smoothing discontinuities at the beginning
        and end of the sampled signal) or tapering function.

        References
        ----------
        .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
               spectra, Dover Publications, New York.
        .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
               The University of Alberta Press, 1975, pp. 106-108.
        .. [3] Wikipedia, "Window function",
               https://en.wikipedia.org/wiki/Window_function
        .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
               "Numerical Recipes", Cambridge University Press, 1986, page 425.

        Examples
        --------
        >>> import numpy as np
        >>> np.hanning(12)
        array([0.        , 0.07937323, 0.29229249, 0.57115742, 0.82743037,
               0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
               0.07937323, 0.        ])

        Plot the window and its frequency response.

        .. plot::
            :include-source:

            import matplotlib.pyplot as plt
            from numpy.fft import fft, fftshift
            window = np.hanning(51)
            plt.plot(window)
            plt.title("Hann window")
            plt.ylabel("Amplitude")
            plt.xlabel("Sample")
            plt.show()

            plt.figure()
            A = fft(window, 2048) / 25.5
            mag = np.abs(fftshift(A))
            freq = np.linspace(-0.5, 0.5, len(A))
            with np.errstate(divide='ignore', invalid='ignore'):
                response = 20 * np.log10(mag)
            response = np.clip(response, -100, 100)
            plt.plot(freq, response)
            plt.title("Frequency response of the Hann window")
            plt.ylabel("Magnitude [dB]")
            plt.xlabel("Normalized frequency [cycles per sample]")
            plt.axis('tight')
            plt.show()

    histogram(a, bins=10, range=None, density=None, weights=None)
        Compute the histogram of a dataset.

        Parameters
        ----------
        a : array_like
            Input data. The histogram is computed over the flattened array.
        bins : int or sequence of scalars or str, optional
            If `bins` is an int, it defines the number of equal-width
            bins in the given range (10, by default). If `bins` is a
            sequence, it defines a monotonically increasing array of bin edges,
            including the rightmost edge, allowing for non-uniform bin widths.

            .. versionadded:: 1.11.0

            If `bins` is a string, it defines the method used to calculate the
            optimal bin width, as defined by `histogram_bin_edges`.

        range : (float, float), optional
            The lower and upper range of the bins.  If not provided, range
            is simply ``(a.min(), a.max())``.  Values outside the range are
            ignored. The first element of the range must be less than or
            equal to the second. `range` affects the automatic bin
            computation as well. While bin width is computed to be optimal
            based on the actual data within `range`, the bin count will fill
            the entire range including portions containing no data.
        weights : array_like, optional
            An array of weights, of the same shape as `a`.  Each value in
            `a` only contributes its associated weight towards the bin count
            (instead of 1). If `density` is True, the weights are
            normalized, so that the integral of the density over the range
            remains 1.
            Please note that the ``dtype`` of `weights` will also become the
            ``dtype`` of the returned accumulator (`hist`), so it must be
            large enough to hold accumulated values as well.
        density : bool, optional
            If ``False``, the result will contain the number of samples in
            each bin. If ``True``, the result is the value of the
            probability *density* function at the bin, normalized such that
            the *integral* over the range is 1. Note that the sum of the
            histogram values will not be equal to 1 unless bins of unity
            width are chosen; it is not a probability *mass* function.

        Returns
        -------
        hist : array
            The values of the histogram. See `density` and `weights` for a
            description of the possible semantics.  If `weights` are given,
            ``hist.dtype`` will be taken from `weights`.
        bin_edges : array of dtype float
            Return the bin edges ``(length(hist)+1)``.


        See Also
        --------
        histogramdd, bincount, searchsorted, digitize, histogram_bin_edges

        Notes
        -----
        All but the last (righthand-most) bin is half-open.  In other words,
        if `bins` is::

          [1, 2, 3, 4]

        then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
        the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which
        *includes* 4.


        Examples
        --------
        >>> import numpy as np
        >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
        (array([0, 2, 1]), array([0, 1, 2, 3]))
        >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
        (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
        >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
        (array([1, 4, 1]), array([0, 1, 2, 3]))

        >>> a = np.arange(5)
        >>> hist, bin_edges = np.histogram(a, density=True)
        >>> hist
        array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])
        >>> hist.sum()
        2.4999999999999996
        >>> np.sum(hist * np.diff(bin_edges))
        1.0

        .. versionadded:: 1.11.0

        Automated Bin Selection Methods example, using 2 peak random data
        with 2000 points.

        .. plot::
            :include-source:

            import matplotlib.pyplot as plt
            import numpy as np

            rng = np.random.RandomState(10)  # deterministic random data
            a = np.hstack((rng.normal(size=1000),
                           rng.normal(loc=5, scale=2, size=1000)))
            plt.hist(a, bins='auto')  # arguments are passed to np.histogram
            plt.title("Histogram with 'auto' bins")
            plt.show()

    histogram2d(x, y, bins=10, range=None, density=None, weights=None)
        Compute the bi-dimensional histogram of two data samples.

        Parameters
        ----------
        x : array_like, shape (N,)
            An array containing the x coordinates of the points to be
            histogrammed.
        y : array_like, shape (N,)
            An array containing the y coordinates of the points to be
            histogrammed.
        bins : int or array_like or [int, int] or [array, array], optional
            The bin specification:

            * If int, the number of bins for the two dimensions (nx=ny=bins).
            * If array_like, the bin edges for the two dimensions
              (x_edges=y_edges=bins).
            * If [int, int], the number of bins in each dimension
              (nx, ny = bins).
            * If [array, array], the bin edges in each dimension
              (x_edges, y_edges = bins).
            * A combination [int, array] or [array, int], where int
              is the number of bins and array is the bin edges.

        range : array_like, shape(2,2), optional
            The leftmost and rightmost edges of the bins along each dimension
            (if not specified explicitly in the `bins` parameters):
            ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
            will be considered outliers and not tallied in the histogram.
        density : bool, optional
            If False, the default, returns the number of samples in each bin.
            If True, returns the probability *density* function at the bin,
            ``bin_count / sample_count / bin_area``.
        weights : array_like, shape(N,), optional
            An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
            Weights are normalized to 1 if `density` is True. If `density` is
            False, the values of the returned histogram are equal to the sum of
            the weights belonging to the samples falling into each bin.

        Returns
        -------
        H : ndarray, shape(nx, ny)
            The bi-dimensional histogram of samples `x` and `y`. Values in `x`
            are histogrammed along the first dimension and values in `y` are
            histogrammed along the second dimension.
        xedges : ndarray, shape(nx+1,)
            The bin edges along the first dimension.
        yedges : ndarray, shape(ny+1,)
            The bin edges along the second dimension.

        See Also
        --------
        histogram : 1D histogram
        histogramdd : Multidimensional histogram

        Notes
        -----
        When `density` is True, then the returned histogram is the sample
        density, defined such that the sum over bins of the product
        ``bin_value * bin_area`` is 1.

        Please note that the histogram does not follow the Cartesian convention
        where `x` values are on the abscissa and `y` values on the ordinate
        axis.  Rather, `x` is histogrammed along the first dimension of the
        array (vertical), and `y` along the second dimension of the array
        (horizontal).  This ensures compatibility with `histogramdd`.

        Examples
        --------
        >>> import numpy as np
        >>> from matplotlib.image import NonUniformImage
        >>> import matplotlib.pyplot as plt

        Construct a 2-D histogram with variable bin width. First define the bin
        edges:

        >>> xedges = [0, 1, 3, 5]
        >>> yedges = [0, 2, 3, 4, 6]

        Next we create a histogram H with random bin content:

        >>> x = np.random.normal(2, 1, 100)
        >>> y = np.random.normal(1, 1, 100)
        >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
        >>> # Histogram does not follow Cartesian convention (see Notes),
        >>> # therefore transpose H for visualization purposes.
        >>> H = H.T

        :func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:

        >>> fig = plt.figure(figsize=(7, 3))
        >>> ax = fig.add_subplot(131, title='imshow: square bins')
        >>> plt.imshow(H, interpolation='nearest', origin='lower',
        ...         extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
        <matplotlib.image.AxesImage object at 0x...>

        :func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:

        >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
        ...         aspect='equal')
        >>> X, Y = np.meshgrid(xedges, yedges)
        >>> ax.pcolormesh(X, Y, H)
        <matplotlib.collections.QuadMesh object at 0x...>

        :class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to
        display actual bin edges with interpolation:

        >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
        ...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
        >>> im = NonUniformImage(ax, interpolation='bilinear')
        >>> xcenters = (xedges[:-1] + xedges[1:]) / 2
        >>> ycenters = (yedges[:-1] + yedges[1:]) / 2
        >>> im.set_data(xcenters, ycenters, H)
        >>> ax.add_image(im)
        >>> plt.show()

        It is also possible to construct a 2-D histogram without specifying bin
        edges:

        >>> # Generate non-symmetric test data
        >>> n = 10000
        >>> x = np.linspace(1, 100, n)
        >>> y = 2*np.log(x) + np.random.rand(n) - 0.5
        >>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
        >>> H, yedges, xedges = np.histogram2d(y, x, bins=20)

        Now we can plot the histogram using
        :func:`pcolormesh <matplotlib.pyplot.pcolormesh>`, and a
        :func:`hexbin <matplotlib.pyplot.hexbin>` for comparison.

        >>> # Plot histogram using pcolormesh
        >>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
        >>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
        >>> ax1.plot(x, 2*np.log(x), 'k-')
        >>> ax1.set_xlim(x.min(), x.max())
        >>> ax1.set_ylim(y.min(), y.max())
        >>> ax1.set_xlabel('x')
        >>> ax1.set_ylabel('y')
        >>> ax1.set_title('histogram2d')
        >>> ax1.grid()

        >>> # Create hexbin plot for comparison
        >>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
        >>> ax2.plot(x, 2*np.log(x), 'k-')
        >>> ax2.set_title('hexbin')
        >>> ax2.set_xlim(x.min(), x.max())
        >>> ax2.set_xlabel('x')
        >>> ax2.grid()

        >>> plt.show()

    histogram_bin_edges(a, bins=10, range=None, weights=None)
        Function to calculate only the edges of the bins used by the `histogram`
        function.

        Parameters
        ----------
        a : array_like
            Input data. The histogram is computed over the flattened array.
        bins : int or sequence of scalars or str, optional
            If `bins` is an int, it defines the number of equal-width
            bins in the given range (10, by default). If `bins` is a
            sequence, it defines the bin edges, including the rightmost
            edge, allowing for non-uniform bin widths.

            If `bins` is a string from the list below, `histogram_bin_edges` will
            use the method chosen to calculate the optimal bin width and
            consequently the number of bins (see the Notes section for more detail
            on the estimators) from the data that falls within the requested range.
            While the bin width will be optimal for the actual data
            in the range, the number of bins will be computed to fill the
            entire range, including the empty portions. For visualisation,
            using the 'auto' option is suggested. Weighted data is not
            supported for automated bin size selection.

            'auto'
                Minimum bin width between the 'sturges' and 'fd' estimators.
                Provides good all-around performance.

            'fd' (Freedman Diaconis Estimator)
                Robust (resilient to outliers) estimator that takes into
                account data variability and data size.

            'doane'
                An improved version of Sturges' estimator that works better
                with non-normal datasets.

            'scott'
                Less robust estimator that takes into account data variability
                and data size.

            'stone'
                Estimator based on leave-one-out cross-validation estimate of
                the integrated squared error. Can be regarded as a generalization
                of Scott's rule.

            'rice'
                Estimator does not take variability into account, only data
                size. Commonly overestimates number of bins required.

            'sturges'
                R's default method, only accounts for data size. Only
                optimal for gaussian data and underestimates number of bins
                for large non-gaussian datasets.

            'sqrt'
                Square root (of data size) estimator, used by Excel and
                other programs for its speed and simplicity.

        range : (float, float), optional
            The lower and upper range of the bins.  If not provided, range
            is simply ``(a.min(), a.max())``.  Values outside the range are
            ignored. The first element of the range must be less than or
            equal to the second. `range` affects the automatic bin
            computation as well. While bin width is computed to be optimal
            based on the actual data within `range`, the bin count will fill
            the entire range including portions containing no data.

        weights : array_like, optional
            An array of weights, of the same shape as `a`.  Each value in
            `a` only contributes its associated weight towards the bin count
            (instead of 1). This is currently not used by any of the bin estimators,
            but may be in the future.

        Returns
        -------
        bin_edges : array of dtype float
            The edges to pass into `histogram`

        See Also
        --------
        histogram

        Notes
        -----
        The methods to estimate the optimal number of bins are well founded
        in literature, and are inspired by the choices R provides for
        histogram visualisation. Note that having the number of bins
        proportional to :math:`n^{1/3}` is asymptotically optimal, which is
        why it appears in most estimators. These are simply plug-in methods
        that give good starting points for number of bins. In the equations
        below, :math:`h` is the binwidth and :math:`n_h` is the number of
        bins. All estimators that compute bin counts are recast to bin width
        using the `ptp` of the data. The final bin count is obtained from
        ``np.round(np.ceil(range / h))``. The final bin width is often less
        than what is returned by the estimators below.

        'auto' (minimum bin width of the 'sturges' and 'fd' estimators)
            A compromise to get a good value. For small datasets the Sturges
            value will usually be chosen, while larger datasets will usually
            default to FD.  Avoids the overly conservative behaviour of FD
            and Sturges for small and large datasets respectively.
            Switchover point is usually :math:`a.size \approx 1000`.

        'fd' (Freedman Diaconis Estimator)
            .. math:: h = 2 \frac{IQR}{n^{1/3}}

            The binwidth is proportional to the interquartile range (IQR)
            and inversely proportional to cube root of a.size. Can be too
            conservative for small datasets, but is quite good for large
            datasets. The IQR is very robust to outliers.

        'scott'
            .. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}}

            The binwidth is proportional to the standard deviation of the
            data and inversely proportional to cube root of ``x.size``. Can
            be too conservative for small datasets, but is quite good for
            large datasets. The standard deviation is not very robust to
            outliers. Values are very similar to the Freedman-Diaconis
            estimator in the absence of outliers.

        'rice'
            .. math:: n_h = 2n^{1/3}

            The number of bins is only proportional to cube root of
            ``a.size``. It tends to overestimate the number of bins and it
            does not take into account data variability.

        'sturges'
            .. math:: n_h = \log _{2}(n) + 1

            The number of bins is the base 2 log of ``a.size``.  This
            estimator assumes normality of data and is too conservative for
            larger, non-normal datasets. This is the default method in R's
            ``hist`` method.

        'doane'
            .. math:: n_h = 1 + \log_{2}(n) +
                            \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right)

                g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right]

                \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}

            An improved version of Sturges' formula that produces better
            estimates for non-normal datasets. This estimator attempts to
            account for the skew of the data.

        'sqrt'
            .. math:: n_h = \sqrt n

            The simplest and fastest estimator. Only takes into account the
            data size.

        Additionally, if the data is of integer dtype, then the binwidth will never
        be less than 1.

        Examples
        --------
        >>> import numpy as np
        >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])
        >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1))
        array([0.  , 0.25, 0.5 , 0.75, 1.  ])
        >>> np.histogram_bin_edges(arr, bins=2)
        array([0. , 2.5, 5. ])

        For consistency with histogram, an array of pre-computed bins is
        passed through unmodified:

        >>> np.histogram_bin_edges(arr, [1, 2])
        array([1, 2])

        This function allows one set of bins to be computed, and reused across
        multiple histograms:

        >>> shared_bins = np.histogram_bin_edges(arr, bins='auto')
        >>> shared_bins
        array([0., 1., 2., 3., 4., 5.])

        >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])
        >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins)
        >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)

        >>> hist_0; hist_1
        array([1, 1, 0, 1, 0])
        array([2, 0, 1, 1, 2])

        Which gives more easily comparable results than using separate bins for
        each histogram:

        >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto')
        >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto')
        >>> hist_0; hist_1
        array([1, 1, 1])
        array([2, 1, 1, 2])
        >>> bins_0; bins_1
        array([0., 1., 2., 3.])
        array([0.  , 1.25, 2.5 , 3.75, 5.  ])

    histogramdd(sample, bins=10, range=None, density=None, weights=None)
        Compute the multidimensional histogram of some data.

        Parameters
        ----------
        sample : (N, D) array, or (N, D) array_like
            The data to be histogrammed.

            Note the unusual interpretation of sample when an array_like:

            * When an array, each row is a coordinate in a D-dimensional space -
              such as ``histogramdd(np.array([p1, p2, p3]))``.
            * When an array_like, each element is the list of values for single
              coordinate - such as ``histogramdd((X, Y, Z))``.

            The first form should be preferred.

        bins : sequence or int, optional
            The bin specification:

            * A sequence of arrays describing the monotonically increasing bin
              edges along each dimension.
            * The number of bins for each dimension (nx, ny, ... =bins)
            * The number of bins for all dimensions (nx=ny=...=bins).

        range : sequence, optional
            A sequence of length D, each an optional (lower, upper) tuple giving
            the outer bin edges to be used if the edges are not given explicitly in
            `bins`.
            An entry of None in the sequence results in the minimum and maximum
            values being used for the corresponding dimension.
            The default, None, is equivalent to passing a tuple of D None values.
        density : bool, optional
            If False, the default, returns the number of samples in each bin.
            If True, returns the probability *density* function at the bin,
            ``bin_count / sample_count / bin_volume``.
        weights : (N,) array_like, optional
            An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
            Weights are normalized to 1 if density is True. If density is False,
            the values of the returned histogram are equal to the sum of the
            weights belonging to the samples falling into each bin.

        Returns
        -------
        H : ndarray
            The multidimensional histogram of sample x. See density and weights
            for the different possible semantics.
        edges : tuple of ndarrays
            A tuple of D arrays describing the bin edges for each dimension.

        See Also
        --------
        histogram: 1-D histogram
        histogram2d: 2-D histogram

        Examples
        --------
        >>> import numpy as np
        >>> rng = np.random.default_rng()
        >>> r = rng.normal(size=(100,3))
        >>> H, edges = np.histogramdd(r, bins = (5, 8, 4))
        >>> H.shape, edges[0].size, edges[1].size, edges[2].size
        ((5, 8, 4), 6, 9, 5)

    hsplit(ary, indices_or_sections)
        Split an array into multiple sub-arrays horizontally (column-wise).

        Please refer to the `split` documentation.  `hsplit` is equivalent
        to `split` with ``axis=1``, the array is always split along the second
        axis except for 1-D arrays, where it is split at ``axis=0``.

        See Also
        --------
        split : Split an array into multiple sub-arrays of equal size.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(16.0).reshape(4, 4)
        >>> x
        array([[ 0.,   1.,   2.,   3.],
               [ 4.,   5.,   6.,   7.],
               [ 8.,   9.,  10.,  11.],
               [12.,  13.,  14.,  15.]])
        >>> np.hsplit(x, 2)
        [array([[  0.,   1.],
               [  4.,   5.],
               [  8.,   9.],
               [12.,  13.]]),
         array([[  2.,   3.],
               [  6.,   7.],
               [10.,  11.],
               [14.,  15.]])]
        >>> np.hsplit(x, np.array([3, 6]))
        [array([[ 0.,   1.,   2.],
               [ 4.,   5.,   6.],
               [ 8.,   9.,  10.],
               [12.,  13.,  14.]]),
         array([[ 3.],
               [ 7.],
               [11.],
               [15.]]),
         array([], shape=(4, 0), dtype=float64)]

        With a higher dimensional array the split is still along the second axis.

        >>> x = np.arange(8.0).reshape(2, 2, 2)
        >>> x
        array([[[0.,  1.],
                [2.,  3.]],
               [[4.,  5.],
                [6.,  7.]]])
        >>> np.hsplit(x, 2)
        [array([[[0.,  1.]],
               [[4.,  5.]]]),
         array([[[2.,  3.]],
               [[6.,  7.]]])]

        With a 1-D array, the split is along axis 0.

        >>> x = np.array([0, 1, 2, 3, 4, 5])
        >>> np.hsplit(x, 2)
        [array([0, 1, 2]), array([3, 4, 5])]

    hstack(tup, *, dtype=None, casting='same_kind')
        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.

        dtype : str or dtype
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`.

            .. versionadded:: 1.24

        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur. Defaults to 'same_kind'.

            .. versionadded:: 1.24

        Returns
        -------
        stacked : ndarray
            The array formed by stacking the given arrays.

        See Also
        --------
        concatenate : Join a sequence of arrays along an existing axis.
        stack : Join a sequence of arrays along a new axis.
        block : Assemble an nd-array from nested lists of blocks.
        vstack : Stack arrays in sequence vertically (row wise).
        dstack : Stack arrays in sequence depth wise (along third axis).
        column_stack : Stack 1-D arrays as columns into a 2-D array.
        hsplit : Split an array into multiple sub-arrays
                 horizontally (column-wise).
        unstack : Split an array into a tuple of sub-arrays along an axis.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array((1,2,3))
        >>> b = np.array((4,5,6))
        >>> np.hstack((a,b))
        array([1, 2, 3, 4, 5, 6])
        >>> a = np.array([[1],[2],[3]])
        >>> b = np.array([[4],[5],[6]])
        >>> np.hstack((a,b))
        array([[1, 4],
               [2, 5],
               [3, 6]])

    i0(x)
        Modified Bessel function of the first kind, order 0.

        Usually denoted :math:`I_0`.

        Parameters
        ----------
        x : array_like of float
            Argument of the Bessel function.

        Returns
        -------
        out : ndarray, shape = x.shape, dtype = float
            The modified Bessel function evaluated at each of the elements of `x`.

        See Also
        --------
        scipy.special.i0, scipy.special.iv, scipy.special.ive

        Notes
        -----
        The scipy implementation is recommended over this function: it is a
        proper ufunc written in C, and more than an order of magnitude faster.

        We use the algorithm published by Clenshaw [1]_ and referenced by
        Abramowitz and Stegun [2]_, for which the function domain is
        partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
        polynomial expansions are employed in each interval. Relative error on
        the domain [0,30] using IEEE arithmetic is documented [3]_ as having a
        peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).

        References
        ----------
        .. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in
               *National Physical Laboratory Mathematical Tables*, vol. 5, London:
               Her Majesty's Stationery Office, 1962.
        .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical
               Functions*, 10th printing, New York: Dover, 1964, pp. 379.
               https://personal.math.ubc.ca/~cbm/aands/page_379.htm
        .. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero

        Examples
        --------
        >>> import numpy as np
        >>> np.i0(0.)
        array(1.0)
        >>> np.i0([0, 1, 2, 3])
        array([1.        , 1.26606588, 2.2795853 , 4.88079259])

    identity(n, dtype=None, *, like=None)
        Return the identity array.

        The identity array is a square array with ones on
        the main diagonal.

        Parameters
        ----------
        n : int
            Number of rows (and columns) in `n` x `n` output.
        dtype : data-type, optional
            Data-type of the output.  Defaults to ``float``.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            `n` x `n` array with its main diagonal set to one,
            and all other elements 0.

        Examples
        --------
        >>> import numpy as np
        >>> np.identity(3)
        array([[1.,  0.,  0.],
               [0.,  1.,  0.],
               [0.,  0.,  1.]])

    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
        --------
        >>> import numpy as np
        >>> 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

    in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None)
        Test whether each element of a 1-D array is also present in a second array.

        .. deprecated:: 2.0
            Use :func:`isin` instead of `in1d` for new code.

        Returns a boolean array the same length as `ar1` that is True
        where an element of `ar1` is in `ar2` and False otherwise.

        Parameters
        ----------
        ar1 : (M,) array_like
            Input array.
        ar2 : array_like
            The values against which to test each value of `ar1`.
        assume_unique : bool, optional
            If True, the input arrays are both assumed to be unique, which
            can speed up the calculation.  Default is False.
        invert : bool, optional
            If True, the values in the returned array are inverted (that is,
            False where an element of `ar1` is in `ar2` and True otherwise).
            Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
            to (but is faster than) ``np.invert(in1d(a, b))``.
        kind : {None, 'sort', 'table'}, optional
            The algorithm to use. This will not affect the final result,
            but will affect the speed and memory use. The default, None,
            will select automatically based on memory considerations.

            * If 'sort', will use a mergesort-based approach. This will have
              a memory usage of roughly 6 times the sum of the sizes of
              `ar1` and `ar2`, not accounting for size of dtypes.
            * If 'table', will use a lookup table approach similar
              to a counting sort. This is only available for boolean and
              integer arrays. This will have a memory usage of the
              size of `ar1` plus the max-min value of `ar2`. `assume_unique`
              has no effect when the 'table' option is used.
            * If None, will automatically choose 'table' if
              the required memory allocation is less than or equal to
              6 times the sum of the sizes of `ar1` and `ar2`,
              otherwise will use 'sort'. This is done to not use
              a large amount of memory by default, even though
              'table' may be faster in most cases. If 'table' is chosen,
              `assume_unique` will have no effect.

            .. versionadded:: 1.8.0

        Returns
        -------
        in1d : (M,) ndarray, bool
            The values `ar1[in1d]` are in `ar2`.

        See Also
        --------
        isin                  : Version of this function that preserves the
                                shape of ar1.

        Notes
        -----
        `in1d` can be considered as an element-wise function version of the
        python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
        equivalent to ``np.array([item in b for item in a])``.
        However, this idea fails if `ar2` is a set, or similar (non-sequence)
        container:  As ``ar2`` is converted to an array, in those cases
        ``asarray(ar2)`` is an object array rather than the expected array of
        contained values.

        Using ``kind='table'`` tends to be faster than `kind='sort'` if the
        following relationship is true:
        ``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
        but may use greater memory. The default value for `kind` will
        be automatically selected based only on memory usage, so one may
        manually set ``kind='table'`` if memory constraints can be relaxed.

        .. versionadded:: 1.4.0

        Examples
        --------
        >>> import numpy as np
        >>> test = np.array([0, 1, 2, 5, 0])
        >>> states = [0, 2]
        >>> mask = np.in1d(test, states)
        >>> mask
        array([ True, False,  True, False,  True])
        >>> test[mask]
        array([0, 2, 0])
        >>> mask = np.in1d(test, states, invert=True)
        >>> mask
        array([False,  True, False,  True, False])
        >>> test[mask]
        array([1, 5])

    indices(dimensions, dtype=<class 'int'>, sparse=False)
        Return an array representing the indices of a grid.

        Compute an array where the subarrays contain index values 0, 1, ...
        varying only along the corresponding axis.

        Parameters
        ----------
        dimensions : sequence of ints
            The shape of the grid.
        dtype : dtype, optional
            Data type of the result.
        sparse : boolean, optional
            Return a sparse representation of the grid instead of a dense
            representation. Default is False.

            .. versionadded:: 1.17

        Returns
        -------
        grid : one ndarray or tuple of ndarrays
            If sparse is False:
                Returns one array of grid indices,
                ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
            If sparse is True:
                Returns a tuple of arrays, with
                ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
                dimensions[i] in the ith place

        See Also
        --------
        mgrid, ogrid, meshgrid

        Notes
        -----
        The output shape in the dense case is obtained by prepending the number
        of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
        is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
        ``(N, r0, ..., rN-1)``.

        The subarrays ``grid[k]`` contains the N-D array of indices along the
        ``k-th`` axis. Explicitly::

            grid[k, i0, i1, ..., iN-1] = ik

        Examples
        --------
        >>> import numpy as np
        >>> grid = np.indices((2, 3))
        >>> grid.shape
        (2, 2, 3)
        >>> grid[0]        # row indices
        array([[0, 0, 0],
               [1, 1, 1]])
        >>> grid[1]        # column indices
        array([[0, 1, 2],
               [0, 1, 2]])

        The indices can be used as an index into an array.

        >>> x = np.arange(20).reshape(5, 4)
        >>> row, col = np.indices((2, 3))
        >>> x[row, col]
        array([[0, 1, 2],
               [4, 5, 6]])

        Note that it would be more straightforward in the above example to
        extract the required elements directly with ``x[:2, :3]``.

        If sparse is set to true, the grid will be returned in a sparse
        representation.

        >>> i, j = np.indices((2, 3), sparse=True)
        >>> i.shape
        (2, 1)
        >>> j.shape
        (1, 3)
        >>> i        # row indices
        array([[0],
               [1]])
        >>> j        # column indices
        array([[0, 1, 2]])

    info(object=None, maxwidth=76, output=None, toplevel='numpy')
        Get help information for an array, function, class, or module.

        Parameters
        ----------
        object : object or str, optional
            Input object or name to get information about. If `object` is
            an `ndarray` instance, information about the array is printed.
            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
            ``None``, in which case ``sys.stdout`` will be used.
            The object has to be opened in 'w' or 'a' mode.
        toplevel : str, optional
            Start search at this level.

        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. ***

        When the argument is an array, information about the array is printed.

        >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64)
        >>> np.info(a)
        class:  ndarray
        shape:  (2, 3)
        strides:  (24, 8)
        itemsize:  8
        aligned:  True
        contiguous:  True
        fortran:  False
        data pointer: 0x562b6e0d2860  # may vary
        byteorder:  little
        byteswap:  False
        type: complex64

    inner(...)
        inner(a, b, /)

        Inner product of two arrays.

        Ordinary inner product of vectors for 1-D arrays (without complex
        conjugation), in higher dimensions a sum product over the last axes.

        Parameters
        ----------
        a, b : array_like
            If `a` and `b` are nonscalar, their last dimensions must match.

        Returns
        -------
        out : ndarray
            If `a` and `b` are both
            scalars or both 1-D arrays then a scalar is returned; otherwise
            an array is returned.
            ``out.shape = (*a.shape[:-1], *b.shape[:-1])``

        Raises
        ------
        ValueError
            If both `a` and `b` are nonscalar and their last dimensions have
            different sizes.

        See Also
        --------
        tensordot : Sum products over arbitrary axes.
        dot : Generalised matrix product, using second last dimension of `b`.
        einsum : Einstein summation convention.

        Notes
        -----
        For vectors (1-D arrays) it computes the ordinary inner-product::

            np.inner(a, b) = sum(a[:]*b[:])

        More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``::

            np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))

        or explicitly::

            np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
                 = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])

        In addition `a` or `b` may be scalars, in which case::

           np.inner(a,b) = a*b

        Examples
        --------
        Ordinary inner product for vectors:

        >>> import numpy as np
        >>> a = np.array([1,2,3])
        >>> b = np.array([0,1,0])
        >>> np.inner(a, b)
        2

        Some multidimensional examples:

        >>> a = np.arange(24).reshape((2,3,4))
        >>> b = np.arange(4)
        >>> c = np.inner(a, b)
        >>> c.shape
        (2, 3)
        >>> c
        array([[ 14,  38,  62],
               [ 86, 110, 134]])

        >>> a = np.arange(2).reshape((1,1,2))
        >>> b = np.arange(6).reshape((3,2))
        >>> c = np.inner(a, b)
        >>> c.shape
        (1, 1, 3)
        >>> c
        array([[[1, 3, 5]]])

        An example where `b` is a scalar:

        >>> np.inner(np.eye(2), 7)
        array([[7., 0.],
               [0., 7.]])

    insert(arr, obj, values, axis=None)
        Insert values along the given axis before the given indices.

        Parameters
        ----------
        arr : array_like
            Input array.
        obj : int, slice or sequence of ints
            Object that defines the index or indices before which `values` is
            inserted.

            .. versionadded:: 1.8.0

            Support for multiple insertions when `obj` is a single scalar or a
            sequence with one element (similar to calling insert multiple
            times).
        values : array_like
            Values to insert into `arr`. If the type of `values` is different
            from that of `arr`, `values` is converted to the type of `arr`.
            `values` should be shaped so that ``arr[...,obj,...] = values``
            is legal.
        axis : int, optional
            Axis along which to insert `values`.  If `axis` is None then `arr`
            is flattened first.

        Returns
        -------
        out : ndarray
            A copy of `arr` with `values` inserted.  Note that `insert`
            does not occur in-place: a new array is returned. If
            `axis` is None, `out` is a flattened array.

        See Also
        --------
        append : Append elements at the end of an array.
        concatenate : Join a sequence of arrays along an existing axis.
        delete : Delete elements from an array.

        Notes
        -----
        Note that for higher dimensional inserts ``obj=0`` behaves very different
        from ``obj=[0]`` just like ``arr[:,0,:] = values`` is different from
        ``arr[:,[0],:] = values``. This is because of the difference between basic
        and advanced :ref:`indexing <basics.indexing>`.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(6).reshape(3, 2)
        >>> a
        array([[0, 1],
               [2, 3],
               [4, 5]])
        >>> np.insert(a, 1, 6)
        array([0, 6, 1, 2, 3, 4, 5])
        >>> np.insert(a, 1, 6, axis=1)
        array([[0, 6, 1],
               [2, 6, 3],
               [4, 6, 5]])

        Difference between sequence and scalars,
        showing how ``obj=[1]`` behaves different from ``obj=1``:

        >>> np.insert(a, [1], [[7],[8],[9]], axis=1)
        array([[0, 7, 1],
               [2, 8, 3],
               [4, 9, 5]])
        >>> np.insert(a, 1, [[7],[8],[9]], axis=1)
        array([[0, 7, 8, 9, 1],
               [2, 7, 8, 9, 3],
               [4, 7, 8, 9, 5]])
        >>> np.array_equal(np.insert(a, 1, [7, 8, 9], axis=1),
        ...                np.insert(a, [1], [[7],[8],[9]], axis=1))
        True

        >>> b = a.flatten()
        >>> b
        array([0, 1, 2, 3, 4, 5])
        >>> np.insert(b, [2, 2], [6, 7])
        array([0, 1, 6, 7, 2, 3, 4, 5])

        >>> np.insert(b, slice(2, 4), [7, 8])
        array([0, 1, 7, 2, 8, 3, 4, 5])

        >>> np.insert(b, [2, 2], [7.13, False]) # type casting
        array([0, 1, 7, 0, 2, 3, 4, 5])

        >>> x = np.arange(8).reshape(2, 4)
        >>> idx = (1, 3)
        >>> np.insert(x, idx, 999, axis=1)
        array([[  0, 999,   1,   2, 999,   3],
               [  4, 999,   5,   6, 999,   7]])

    interp(x, xp, fp, left=None, right=None, period=None)
        One-dimensional linear interpolation for monotonically increasing sample points.

        Returns the one-dimensional piecewise linear interpolant to a function
        with given discrete data points (`xp`, `fp`), evaluated at `x`.

        Parameters
        ----------
        x : array_like
            The x-coordinates at which to evaluate the interpolated values.

        xp : 1-D sequence of floats
            The x-coordinates of the data points, must be increasing if argument
            `period` is not specified. Otherwise, `xp` is internally sorted after
            normalizing the periodic boundaries with ``xp = xp % period``.

        fp : 1-D sequence of float or complex
            The y-coordinates of the data points, same length as `xp`.

        left : optional float or complex corresponding to fp
            Value to return for `x < xp[0]`, default is `fp[0]`.

        right : optional float or complex corresponding to fp
            Value to return for `x > xp[-1]`, default is `fp[-1]`.

        period : None or float, optional
            A period for the x-coordinates. This parameter allows the proper
            interpolation of angular x-coordinates. Parameters `left` and `right`
            are ignored if `period` is specified.

            .. versionadded:: 1.10.0

        Returns
        -------
        y : float or complex (corresponding to fp) or ndarray
            The interpolated values, same shape as `x`.

        Raises
        ------
        ValueError
            If `xp` and `fp` have different length
            If `xp` or `fp` are not 1-D sequences
            If `period == 0`

        See Also
        --------
        scipy.interpolate

        Warnings
        --------
        The x-coordinate sequence is expected to be increasing, but this is not
        explicitly enforced.  However, if the sequence `xp` is non-increasing,
        interpolation results are meaningless.

        Note that, since NaN is unsortable, `xp` also cannot contain NaNs.

        A simple check for `xp` being strictly increasing is::

            np.all(np.diff(xp) > 0)

        Examples
        --------
        >>> import numpy as np
        >>> xp = [1, 2, 3]
        >>> fp = [3, 2, 0]
        >>> np.interp(2.5, xp, fp)
        1.0
        >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
        array([3.  , 3.  , 2.5 , 0.56, 0.  ])
        >>> UNDEF = -99.0
        >>> np.interp(3.14, xp, fp, right=UNDEF)
        -99.0

        Plot an interpolant to the sine function:

        >>> x = np.linspace(0, 2*np.pi, 10)
        >>> y = np.sin(x)
        >>> xvals = np.linspace(0, 2*np.pi, 50)
        >>> yinterp = np.interp(xvals, x, y)
        >>> import matplotlib.pyplot as plt
        >>> plt.plot(x, y, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.plot(xvals, yinterp, '-x')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.show()

        Interpolation with periodic x-coordinates:

        >>> x = [-180, -170, -185, 185, -10, -5, 0, 365]
        >>> xp = [190, -190, 350, -350]
        >>> fp = [5, 10, 3, 4]
        >>> np.interp(x, xp, fp, period=360)
        array([7.5 , 5.  , 8.75, 6.25, 3.  , 3.25, 3.5 , 3.75])

        Complex interpolation:

        >>> x = [1.5, 4.0]
        >>> xp = [2,3,5]
        >>> fp = [1.0j, 0, 2+3j]
        >>> np.interp(x, xp, fp)
        array([0.+1.j , 1.+1.5j])

    intersect1d(ar1, ar2, assume_unique=False, return_indices=False)
        Find the intersection of two arrays.

        Return the sorted, unique values that are in both of the input arrays.

        Parameters
        ----------
        ar1, ar2 : array_like
            Input arrays. Will be flattened if not already 1D.
        assume_unique : bool
            If True, the input arrays are both assumed to be unique, which
            can speed up the calculation.  If True but ``ar1`` or ``ar2`` are not
            unique, incorrect results and out-of-bounds indices could result.
            Default is False.
        return_indices : bool
            If True, the indices which correspond to the intersection of the two
            arrays are returned. The first instance of a value is used if there are
            multiple. Default is False.

            .. versionadded:: 1.15.0

        Returns
        -------
        intersect1d : ndarray
            Sorted 1D array of common and unique elements.
        comm1 : ndarray
            The indices of the first occurrences of the common values in `ar1`.
            Only provided if `return_indices` is True.
        comm2 : ndarray
            The indices of the first occurrences of the common values in `ar2`.
            Only provided if `return_indices` is True.

        Examples
        --------
        >>> import numpy as np
        >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
        array([1, 3])

        To intersect more than two arrays, use functools.reduce:

        >>> from functools import reduce
        >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
        array([3])

        To return the indices of the values common to the input arrays
        along with the intersected values:

        >>> x = np.array([1, 1, 2, 3, 4])
        >>> y = np.array([2, 1, 4, 6])
        >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
        >>> x_ind, y_ind
        (array([0, 2, 4]), array([1, 0, 2]))
        >>> xy, x[x_ind], y[y_ind]
        (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))

    is_busday(...)
        is_busday(
            dates,
            weekmask='1111100',
            holidays=None,
            busdaycal=None,
            out=None
        )

        Calculates which of the given dates are valid days, and which are not.

        .. versionadded:: 1.7.0

        Parameters
        ----------
        dates : array_like of datetime64[D]
            The array of dates to process.
        weekmask : str or array_like of bool, optional
            A seven-element array indicating which of Monday through Sunday are
            valid days. May be specified as a length-seven list or array, like
            [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
            like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
            weekdays, optionally separated by white space. Valid abbreviations
            are: Mon Tue Wed Thu Fri Sat Sun
        holidays : array_like of datetime64[D], optional
            An array of dates to consider as invalid dates.  They may be
            specified in any order, and NaT (not-a-time) dates are ignored.
            This list is saved in a normalized form that is suited for
            fast calculations of valid days.
        busdaycal : busdaycalendar, optional
            A `busdaycalendar` object which specifies the valid days. If this
            parameter is provided, neither weekmask nor holidays may be
            provided.
        out : array of bool, optional
            If provided, this array is filled with the result.

        Returns
        -------
        out : array of bool
            An array with the same shape as ``dates``, containing True for
            each valid day, and False for each invalid day.

        See Also
        --------
        busdaycalendar : An object that specifies a custom set of valid days.
        busday_offset : Applies an offset counted in valid days.
        busday_count : Counts how many valid days are in a half-open date range.

        Examples
        --------
        >>> import numpy as np
        >>> # The weekdays are Friday, Saturday, and Monday
        ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],
        ...                 holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
        array([False, False,  True])

    isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)
        Returns a boolean array where two arrays are element-wise equal within a
        tolerance.

        The tolerance values are positive, typically very small numbers.  The
        relative difference (`rtol` * abs(`b`)) and the absolute difference
        `atol` are added together to compare against the absolute difference
        between `a` and `b`.

        .. warning:: The default `atol` is not appropriate for comparing numbers
                     with magnitudes much smaller than one (see Notes).

        Parameters
        ----------
        a, b : array_like
            Input arrays to compare.
        rtol : array_like
            The relative tolerance parameter (see Notes).
        atol : array_like
            The absolute tolerance parameter (see Notes).
        equal_nan : bool
            Whether to compare NaN's as equal.  If True, NaN's in `a` will be
            considered equal to NaN's in `b` in the output array.

        Returns
        -------
        y : array_like
            Returns a boolean array of where `a` and `b` are equal within the
            given tolerance. If both `a` and `b` are scalars, returns a single
            boolean value.

        See Also
        --------
        allclose
        math.isclose

        Notes
        -----
        .. versionadded:: 1.7.0

        For finite values, isclose uses the following equation to test whether
        two floating point values are equivalent.::

         absolute(a - b) <= (atol + rtol * absolute(b))

        Unlike the built-in `math.isclose`, the above equation is not symmetric
        in `a` and `b` -- it assumes `b` is the reference value -- so that
        `isclose(a, b)` might be different from `isclose(b, a)`.

        The default value of `atol` is not appropriate when the reference value
        `b` has magnitude smaller than one. For example, it is unlikely that
        ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet
        ``isclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure
        to select `atol` for the use case at hand, especially for defining the
        threshold below which a non-zero value in `a` will be considered "close"
        to a very small or zero value in `b`.

        `isclose` is not defined for non-numeric data types.
        :class:`bool` is considered a numeric data-type for this purpose.

        Examples
        --------
        >>> import numpy as np
        >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
        array([ True, False])

        >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
        array([ True, True])

        >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
        array([False,  True])

        >>> np.isclose([1.0, np.nan], [1.0, np.nan])
        array([ True, False])

        >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
        array([ True, True])

        >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
        array([ True, False])

        >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
        array([False, False])

        >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
        array([ True,  True])

        >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
        array([False,  True])

    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
        --------
        >>> import numpy as np
        >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
        array([ True, False, False, False, False,  True])

    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
        --------
        >>> import numpy as np
        >>> np.iscomplexobj(1)
        False
        >>> np.iscomplexobj(1+0j)
        True
        >>> np.iscomplexobj([3, 1+0j, True])
        True

    isdtype(dtype, kind)
        Determine if a provided dtype is of a specified data type ``kind``.

        This function only supports built-in NumPy's data types.
        Third-party dtypes are not yet supported.

        Parameters
        ----------
        dtype : dtype
            The input dtype.
        kind : dtype or str or tuple of dtypes/strs.
            dtype or dtype kind. Allowed dtype kinds are:
            * ``'bool'`` : boolean kind
            * ``'signed integer'`` : signed integer data types
            * ``'unsigned integer'`` : unsigned integer data types
            * ``'integral'`` : integer data types
            * ``'real floating'`` : real-valued floating-point data types
            * ``'complex floating'`` : complex floating-point data types
            * ``'numeric'`` : numeric data types

        Returns
        -------
        out : bool

        See Also
        --------
        issubdtype

        Examples
        --------
        >>> import numpy as np
        >>> np.isdtype(np.float32, np.float64)
        False
        >>> np.isdtype(np.float32, "real floating")
        True
        >>> np.isdtype(np.complex128, ("real floating", "complex floating"))
        True

    isfortran(a)
        Check if the array is Fortran contiguous but *not* C contiguous.

        This function is obsolete. If you only want to check if an array is Fortran
        contiguous use ``a.flags.f_contiguous`` instead.

        Parameters
        ----------
        a : ndarray
            Input array.

        Returns
        -------
        isfortran : bool
            Returns True if the array is Fortran contiguous but *not* C contiguous.


        Examples
        --------

        np.array allows to specify whether the array is written in C-contiguous
        order (last index varies the fastest), or FORTRAN-contiguous order in
        memory (first index varies the fastest).

        >>> import numpy as np
        >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
        >>> a
        array([[1, 2, 3],
               [4, 5, 6]])
        >>> np.isfortran(a)
        False

        >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
        >>> b
        array([[1, 2, 3],
               [4, 5, 6]])
        >>> np.isfortran(b)
        True


        The transpose of a C-ordered array is a FORTRAN-ordered array.

        >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
        >>> a
        array([[1, 2, 3],
               [4, 5, 6]])
        >>> np.isfortran(a)
        False
        >>> b = a.T
        >>> b
        array([[1, 4],
               [2, 5],
               [3, 6]])
        >>> np.isfortran(b)
        True

        C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.

        >>> np.isfortran(np.array([1, 2], order='F'))
        False

    isin(element, test_elements, assume_unique=False, invert=False, *, kind=None)
        Calculates ``element in test_elements``, broadcasting over `element` only.
        Returns a boolean array of the same shape as `element` that is True
        where an element of `element` is in `test_elements` and False otherwise.

        Parameters
        ----------
        element : array_like
            Input array.
        test_elements : array_like
            The values against which to test each value of `element`.
            This argument is flattened if it is an array or array_like.
            See notes for behavior with non-array-like parameters.
        assume_unique : bool, optional
            If True, the input arrays are both assumed to be unique, which
            can speed up the calculation.  Default is False.
        invert : bool, optional
            If True, the values in the returned array are inverted, as if
            calculating `element not in test_elements`. Default is False.
            ``np.isin(a, b, invert=True)`` is equivalent to (but faster
            than) ``np.invert(np.isin(a, b))``.
        kind : {None, 'sort', 'table'}, optional
            The algorithm to use. This will not affect the final result,
            but will affect the speed and memory use. The default, None,
            will select automatically based on memory considerations.

            * If 'sort', will use a mergesort-based approach. This will have
              a memory usage of roughly 6 times the sum of the sizes of
              `element` and `test_elements`, not accounting for size of dtypes.
            * If 'table', will use a lookup table approach similar
              to a counting sort. This is only available for boolean and
              integer arrays. This will have a memory usage of the
              size of `element` plus the max-min value of `test_elements`.
              `assume_unique` has no effect when the 'table' option is used.
            * If None, will automatically choose 'table' if
              the required memory allocation is less than or equal to
              6 times the sum of the sizes of `element` and `test_elements`,
              otherwise will use 'sort'. This is done to not use
              a large amount of memory by default, even though
              'table' may be faster in most cases. If 'table' is chosen,
              `assume_unique` will have no effect.


        Returns
        -------
        isin : ndarray, bool
            Has the same shape as `element`. The values `element[isin]`
            are in `test_elements`.

        Notes
        -----

        `isin` is an element-wise function version of the python keyword `in`.
        ``isin(a, b)`` is roughly equivalent to
        ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.

        `element` and `test_elements` are converted to arrays if they are not
        already. If `test_elements` is a set (or other non-sequence collection)
        it will be converted to an object array with one element, rather than an
        array of the values contained in `test_elements`. This is a consequence
        of the `array` constructor's way of handling non-sequence collections.
        Converting the set to a list usually gives the desired behavior.

        Using ``kind='table'`` tends to be faster than `kind='sort'` if the
        following relationship is true:
        ``log10(len(test_elements)) >
        (log10(max(test_elements)-min(test_elements)) - 2.27) / 0.927``,
        but may use greater memory. The default value for `kind` will
        be automatically selected based only on memory usage, so one may
        manually set ``kind='table'`` if memory constraints can be relaxed.

        .. versionadded:: 1.13.0

        Examples
        --------
        >>> import numpy as np
        >>> element = 2*np.arange(4).reshape((2, 2))
        >>> element
        array([[0, 2],
               [4, 6]])
        >>> test_elements = [1, 2, 4, 8]
        >>> mask = np.isin(element, test_elements)
        >>> mask
        array([[False,  True],
               [ True, False]])
        >>> element[mask]
        array([2, 4])

        The indices of the matched values can be obtained with `nonzero`:

        >>> np.nonzero(mask)
        (array([0, 1]), array([1, 0]))

        The test can also be inverted:

        >>> mask = np.isin(element, test_elements, invert=True)
        >>> mask
        array([[ True, False],
               [False,  True]])
        >>> element[mask]
        array([0, 6])

        Because of how `array` handles sets, the following does not
        work as expected:

        >>> test_set = {1, 2, 4, 8}
        >>> np.isin(element, test_set)
        array([[False, False],
               [False, False]])

        Casting the set to a list gives the expected result:

        >>> np.isin(element, list(test_set))
        array([[False,  True],
               [ True, False]])

    isneginf(x, out=None)
        Test element-wise for negative infinity, return result as bool array.

        Parameters
        ----------
        x : array_like
            The input array.
        out : array_like, optional
            A location into which the result is stored. If provided, it must have a
            shape that the input broadcasts to. If not provided or None, a
            freshly-allocated boolean array is returned.

        Returns
        -------
        out : ndarray
            A boolean array with the same dimensions as the input.
            If second argument is not supplied then a numpy boolean array is
            returned with values True where the corresponding element of the
            input is negative infinity and values False where the element of
            the input is not negative infinity.

            If a second argument is supplied the result is stored there. If the
            type of that array is a numeric type the result is represented as
            zeros and ones, if the type is boolean then as False and True. The
            return value `out` is then a reference to that array.

        See Also
        --------
        isinf, isposinf, isnan, isfinite

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754).

        Errors result if the second argument is also supplied when x is a scalar
        input, if first and second arguments have different shapes, or if the
        first argument has complex values.

        Examples
        --------
        >>> import numpy as np
        >>> np.isneginf(-np.inf)
        True
        >>> np.isneginf(np.inf)
        False
        >>> np.isneginf([-np.inf, 0., np.inf])
        array([ True, False, False])

        >>> x = np.array([-np.inf, 0., np.inf])
        >>> y = np.array([2, 2, 2])
        >>> np.isneginf(x, y)
        array([1, 0, 0])
        >>> y
        array([1, 0, 0])

    isposinf(x, out=None)
        Test element-wise for positive infinity, return result as bool array.

        Parameters
        ----------
        x : array_like
            The input array.
        out : array_like, optional
            A location into which the result is stored. If provided, it must have a
            shape that the input broadcasts to. If not provided or None, a
            freshly-allocated boolean array is returned.

        Returns
        -------
        out : ndarray
            A boolean array with the same dimensions as the input.
            If second argument is not supplied then a boolean array is returned
            with values True where the corresponding element of the input is
            positive infinity and values False where the element of the input is
            not positive infinity.

            If a second argument is supplied the result is stored there. If the
            type of that array is a numeric type the result is represented as zeros
            and ones, if the type is boolean then as False and True.
            The return value `out` is then a reference to that array.

        See Also
        --------
        isinf, isneginf, isfinite, isnan

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754).

        Errors result if the second argument is also supplied when x is a scalar
        input, if first and second arguments have different shapes, or if the
        first argument has complex values

        Examples
        --------
        >>> import numpy as np
        >>> np.isposinf(np.inf)
        True
        >>> np.isposinf(-np.inf)
        False
        >>> np.isposinf([-np.inf, 0., np.inf])
        array([False, False,  True])

        >>> x = np.array([-np.inf, 0., np.inf])
        >>> y = np.array([2, 2, 2])
        >>> np.isposinf(x, y)
        array([0, 0, 1])
        >>> y
        array([0, 0, 1])

    isreal(x)
        Returns a bool array, where True if input element is real.

        If element has complex type with zero imaginary part, the return value
        for that element is True.

        Parameters
        ----------
        x : array_like
            Input array.

        Returns
        -------
        out : ndarray, bool
            Boolean array of same shape as `x`.

        Notes
        -----
        `isreal` may behave unexpectedly for string or object arrays (see examples)

        See Also
        --------
        iscomplex
        isrealobj : Return True if x is not a complex type.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
        >>> np.isreal(a)
        array([False,  True,  True,  True,  True, False])

        The function does not work on string arrays.

        >>> a = np.array([2j, "a"], dtype="U")
        >>> np.isreal(a)  # Warns about non-elementwise comparison
        False

        Returns True for all elements in input array of ``dtype=object`` even if
        any of the elements is complex.

        >>> a = np.array([1, "2", 3+4j], dtype=object)
        >>> np.isreal(a)
        array([ True,  True,  True])

        isreal should not be used with object arrays

        >>> a = np.array([1+2j, 2+1j], dtype=object)
        >>> np.isreal(a)
        array([ True,  True])

    isrealobj(x)
        Return True if x is a not complex type or an array of complex numbers.

        The type of the input is checked, not the value. So even if the input
        has an imaginary part equal to zero, `isrealobj` evaluates to False
        if the data type is complex.

        Parameters
        ----------
        x : any
            The input can be of any type and shape.

        Returns
        -------
        y : bool
            The return value, False if `x` is of a complex type.

        See Also
        --------
        iscomplexobj, isreal

        Notes
        -----
        The function is only meant for arrays with numerical values but it
        accepts all other objects. Since it assumes array input, the return
        value of other objects may be True.

        >>> np.isrealobj('A string')
        True
        >>> np.isrealobj(False)
        True
        >>> np.isrealobj(None)
        True

        Examples
        --------
        >>> import numpy as np
        >>> np.isrealobj(1)
        True
        >>> np.isrealobj(1+0j)
        False
        >>> np.isrealobj([3, 1+0j, True])
        False

    isscalar(element)
        Returns True if the type of `element` is a scalar type.

        Parameters
        ----------
        element : any
            Input argument, can be of any type and shape.

        Returns
        -------
        val : bool
            True if `element` is a scalar type, False if it is not.

        See Also
        --------
        ndim : Get the number of dimensions of an array

        Notes
        -----
        If you need a stricter way to identify a *numerical* scalar, use
        ``isinstance(x, numbers.Number)``, as that returns ``False`` for most
        non-numerical elements such as strings.

        In most cases ``np.ndim(x) == 0`` should be used instead of this function,
        as that will also return true for 0d arrays. This is how numpy overloads
        functions in the style of the ``dx`` arguments to `gradient` and
        the ``bins`` argument to `histogram`. Some key differences:

        +------------------------------------+---------------+-------------------+
        | x                                  |``isscalar(x)``|``np.ndim(x) == 0``|
        +====================================+===============+===================+
        | PEP 3141 numeric objects           | ``True``      | ``True``          |
        | (including builtins)               |               |                   |
        +------------------------------------+---------------+-------------------+
        | builtin string and buffer objects  | ``True``      | ``True``          |
        +------------------------------------+---------------+-------------------+
        | other builtin objects, like        | ``False``     | ``True``          |
        | `pathlib.Path`, `Exception`,       |               |                   |
        | the result of `re.compile`         |               |                   |
        +------------------------------------+---------------+-------------------+
        | third-party objects like           | ``False``     | ``True``          |
        | `matplotlib.figure.Figure`         |               |                   |
        +------------------------------------+---------------+-------------------+
        | zero-dimensional numpy arrays      | ``False``     | ``True``          |
        +------------------------------------+---------------+-------------------+
        | other numpy arrays                 | ``False``     | ``False``         |
        +------------------------------------+---------------+-------------------+
        | `list`, `tuple`, and other         | ``False``     | ``False``         |
        | sequence objects                   |               |                   |
        +------------------------------------+---------------+-------------------+

        Examples
        --------
        >>> import numpy as np

        >>> np.isscalar(3.1)
        True

        >>> np.isscalar(np.array(3.1))
        False

        >>> np.isscalar([3.1])
        False

        >>> np.isscalar(False)
        True

        >>> np.isscalar('numpy')
        True

        NumPy supports PEP 3141 numbers:

        >>> from fractions import Fraction
        >>> np.isscalar(Fraction(5, 17))
        True
        >>> from numbers import Number
        >>> np.isscalar(Number())
        True

    issubdtype(arg1, arg2)
        Returns True if first argument is a typecode lower/equal in type hierarchy.

        This is like the builtin :func:`issubclass`, but for `dtype`\ s.

        Parameters
        ----------
        arg1, arg2 : dtype_like
            `dtype` or object coercible to one

        Returns
        -------
        out : bool

        See Also
        --------
        :ref:`arrays.scalars` : Overview of the numpy type hierarchy.

        Examples
        --------
        `issubdtype` can be used to check the type of arrays:

        >>> ints = np.array([1, 2, 3], dtype=np.int32)
        >>> np.issubdtype(ints.dtype, np.integer)
        True
        >>> np.issubdtype(ints.dtype, np.floating)
        False

        >>> floats = np.array([1, 2, 3], dtype=np.float32)
        >>> np.issubdtype(floats.dtype, np.integer)
        False
        >>> np.issubdtype(floats.dtype, np.floating)
        True

        Similar types of different sizes are not subdtypes of each other:

        >>> np.issubdtype(np.float64, np.float32)
        False
        >>> np.issubdtype(np.float32, np.float64)
        False

        but both are subtypes of `floating`:

        >>> np.issubdtype(np.float64, np.floating)
        True
        >>> np.issubdtype(np.float32, np.floating)
        True

        For convenience, dtype-like objects are allowed too:

        >>> np.issubdtype('S1', np.bytes_)
        True
        >>> np.issubdtype('i4', np.signedinteger)
        True

    iterable(y)
        Check whether or not an object can be iterated over.

        Parameters
        ----------
        y : object
          Input object.

        Returns
        -------
        b : bool
          Return ``True`` if the object has an iterator method or is a
          sequence and ``False`` otherwise.


        Examples
        --------
        >>> import numpy as np
        >>> np.iterable([1, 2, 3])
        True
        >>> np.iterable(2)
        False

        Notes
        -----
        In most cases, the results of ``np.iterable(obj)`` are consistent with
        ``isinstance(obj, collections.abc.Iterable)``. One notable exception is
        the treatment of 0-dimensional arrays::

            >>> from collections.abc import Iterable
            >>> a = np.array(1.0)  # 0-dimensional numpy array
            >>> isinstance(a, Iterable)
            True
            >>> np.iterable(a)
            False

    ix_(*args)
        Construct an open mesh from multiple sequences.

        This function takes N 1-D sequences and returns N outputs with N
        dimensions each, such that the shape is 1 in all but one dimension
        and the dimension with the non-unit shape value cycles through all
        N dimensions.

        Using `ix_` one can quickly construct index arrays that will index
        the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
        ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.

        Parameters
        ----------
        args : 1-D sequences
            Each sequence should be of integer or boolean type.
            Boolean sequences will be interpreted as boolean masks for the
            corresponding dimension (equivalent to passing in
            ``np.nonzero(boolean_sequence)``).

        Returns
        -------
        out : tuple of ndarrays
            N arrays with N dimensions each, with N the number of input
            sequences. Together these arrays form an open mesh.

        See Also
        --------
        ogrid, mgrid, meshgrid

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(10).reshape(2, 5)
        >>> a
        array([[0, 1, 2, 3, 4],
               [5, 6, 7, 8, 9]])
        >>> ixgrid = np.ix_([0, 1], [2, 4])
        >>> ixgrid
        (array([[0],
               [1]]), array([[2, 4]]))
        >>> ixgrid[0].shape, ixgrid[1].shape
        ((2, 1), (1, 2))
        >>> a[ixgrid]
        array([[2, 4],
               [7, 9]])

        >>> ixgrid = np.ix_([True, True], [2, 4])
        >>> a[ixgrid]
        array([[2, 4],
               [7, 9]])
        >>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
        >>> a[ixgrid]
        array([[2, 4],
               [7, 9]])

    kaiser(M, beta)
        Return the Kaiser window.

        The Kaiser window is a taper formed by using a Bessel function.

        Parameters
        ----------
        M : int
            Number of points in the output window. If zero or less, an
            empty array is returned.
        beta : float
            Shape parameter for window.

        Returns
        -------
        out : array
            The window, with the maximum value normalized to one (the value
            one appears only if the number of samples is odd).

        See Also
        --------
        bartlett, blackman, hamming, hanning

        Notes
        -----
        The Kaiser window is defined as

        .. math::  w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}}
                   \right)/I_0(\beta)

        with

        .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2},

        where :math:`I_0` is the modified zeroth-order Bessel function.

        The Kaiser was named for Jim Kaiser, who discovered a simple
        approximation to the DPSS window based on Bessel functions.  The Kaiser
        window is a very good approximation to the Digital Prolate Spheroidal
        Sequence, or Slepian window, which is the transform which maximizes the
        energy in the main lobe of the window relative to total energy.

        The Kaiser can approximate many other windows by varying the beta
        parameter.

        ====  =======================
        beta  Window shape
        ====  =======================
        0     Rectangular
        5     Similar to a Hamming
        6     Similar to a Hanning
        8.6   Similar to a Blackman
        ====  =======================

        A beta value of 14 is probably a good starting point. Note that as beta
        gets large, the window narrows, and so the number of samples needs to be
        large enough to sample the increasingly narrow spike, otherwise NaNs will
        get returned.

        Most references to the Kaiser window come from the signal processing
        literature, where it is used as one of many windowing functions for
        smoothing values.  It is also known as an apodization (which means
        "removing the foot", i.e. smoothing discontinuities at the beginning
        and end of the sampled signal) or tapering function.

        References
        ----------
        .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by
               digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
               John Wiley and Sons, New York, (1966).
        .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The
               University of Alberta Press, 1975, pp. 177-178.
        .. [3] Wikipedia, "Window function",
               https://en.wikipedia.org/wiki/Window_function

        Examples
        --------
        >>> import numpy as np
        >>> import matplotlib.pyplot as plt
        >>> np.kaiser(12, 14)
         array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
                2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
                9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
                4.65200189e-02, 3.46009194e-03, 7.72686684e-06])


        Plot the window and the frequency response.

        .. plot::
            :include-source:

            import matplotlib.pyplot as plt
            from numpy.fft import fft, fftshift
            window = np.kaiser(51, 14)
            plt.plot(window)
            plt.title("Kaiser window")
            plt.ylabel("Amplitude")
            plt.xlabel("Sample")
            plt.show()

            plt.figure()
            A = fft(window, 2048) / 25.5
            mag = np.abs(fftshift(A))
            freq = np.linspace(-0.5, 0.5, len(A))
            response = 20 * np.log10(mag)
            response = np.clip(response, -100, 100)
            plt.plot(freq, response)
            plt.title("Frequency response of Kaiser window")
            plt.ylabel("Magnitude [dB]")
            plt.xlabel("Normalized frequency [cycles per sample]")
            plt.axis('tight')
            plt.show()

    kron(a, b)
        Kronecker product of two arrays.

        Computes the Kronecker product, a composite array made of blocks of the
        second array scaled by the first.

        Parameters
        ----------
        a, b : array_like

        Returns
        -------
        out : ndarray

        See Also
        --------
        outer : The outer product

        Notes
        -----
        The function assumes that the number of dimensions of `a` and `b`
        are the same, if necessary prepending the smallest with ones.
        If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``,
        the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``.
        The elements are products of elements from `a` and `b`, organized
        explicitly by::

            kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]

        where::

            kt = it * st + jt,  t = 0,...,N

        In the common 2-D case (N=1), the block structure can be visualized::

            [[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
             [  ...                              ...   ],
             [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]


        Examples
        --------
        >>> import numpy as np
        >>> np.kron([1,10,100], [5,6,7])
        array([  5,   6,   7, ..., 500, 600, 700])
        >>> np.kron([5,6,7], [1,10,100])
        array([  5,  50, 500, ...,   7,  70, 700])

        >>> np.kron(np.eye(2), np.ones((2,2)))
        array([[1.,  1.,  0.,  0.],
               [1.,  1.,  0.,  0.],
               [0.,  0.,  1.,  1.],
               [0.,  0.,  1.,  1.]])

        >>> a = np.arange(100).reshape((2,5,2,5))
        >>> b = np.arange(24).reshape((2,3,4))
        >>> c = np.kron(a,b)
        >>> c.shape
        (2, 10, 6, 20)
        >>> I = (1,3,0,2)
        >>> J = (0,2,1)
        >>> J1 = (0,) + J             # extend to ndim=4
        >>> S1 = (1,) + b.shape
        >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
        >>> c[K] == a[I]*b[J]
        True

    lexsort(...)
        lexsort(keys, axis=-1)

        Perform an indirect stable sort using a sequence of keys.

        Given multiple sorting keys, lexsort returns an array of integer indices
        that describes the sort order by multiple keys. The last key in the
        sequence is used for the primary sort order, ties are broken by the
        second-to-last key, and so on.

        Parameters
        ----------
        keys : (k, m, n, ...) array-like
            The `k` keys to be sorted. The *last* key (e.g, the last
            row if `keys` is a 2D array) is the primary sort key.
            Each element of `keys` along the zeroth axis must be
            an array-like object of the same shape.
        axis : int, optional
            Axis to be indirectly sorted. By default, sort over the last axis
            of each sequence. Separate slices along `axis` sorted over
            independently; see last example.

        Returns
        -------
        indices : (m, n, ...) ndarray of ints
            Array of indices that sort the keys along the specified axis.

        See Also
        --------
        argsort : Indirect sort.
        ndarray.sort : In-place sort.
        sort : Return a sorted copy of an array.

        Examples
        --------
        Sort names: first by surname, then by name.

        >>> import numpy as np
        >>> surnames =    ('Hertz',    'Galilei', 'Hertz')
        >>> first_names = ('Heinrich', 'Galileo', 'Gustav')
        >>> ind = np.lexsort((first_names, surnames))
        >>> ind
        array([1, 2, 0])

        >>> [surnames[i] + ", " + first_names[i] for i in ind]
        ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']

        Sort according to two numerical keys, first by elements
        of ``a``, then breaking ties according to elements of ``b``:

        >>> a = [1, 5, 1, 4, 3, 4, 4]  # First sequence
        >>> b = [9, 4, 0, 4, 0, 2, 1]  # Second sequence
        >>> ind = np.lexsort((b, a))  # Sort by `a`, then by `b`
        >>> ind
        array([2, 0, 4, 6, 5, 3, 1])
        >>> [(a[i], b[i]) for i in ind]
        [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

        Compare against `argsort`, which would sort each key independently.

        >>> np.argsort((b, a), kind='stable')
        array([[2, 4, 6, 5, 1, 3, 0],
               [0, 2, 4, 3, 5, 6, 1]])

        To sort lexicographically with `argsort`, we would need to provide a
        structured array.

        >>> x = np.array([(ai, bi) for ai, bi in zip(a, b)],
        ...              dtype = np.dtype([('x', int), ('y', int)]))
        >>> np.argsort(x)  # or np.argsort(x, order=('x', 'y'))
        array([2, 0, 4, 6, 5, 3, 1])

        The zeroth axis of `keys` always corresponds with the sequence of keys,
        so 2D arrays are treated just like other sequences of keys.

        >>> arr = np.asarray([b, a])
        >>> ind2 = np.lexsort(arr)
        >>> np.testing.assert_equal(ind2, ind)

        Accordingly, the `axis` parameter refers to an axis of *each* key, not of
        the `keys` argument itself. For instance, the array ``arr`` is treated as
        a sequence of two 1-D keys, so specifying ``axis=0`` is equivalent to
        using the default axis, ``axis=-1``.

        >>> np.testing.assert_equal(np.lexsort(arr, axis=0),
        ...                         np.lexsort(arr, axis=-1))

        For higher-dimensional arrays, the axis parameter begins to matter. The
        resulting array has the same shape as each key, and the values are what
        we would expect if `lexsort` were performed on corresponding slices
        of the keys independently. For instance,

        >>> x = [[1, 2, 3, 4],
        ...      [4, 3, 2, 1],
        ...      [2, 1, 4, 3]]
        >>> y = [[2, 2, 1, 1],
        ...      [1, 2, 1, 2],
        ...      [1, 1, 2, 1]]
        >>> np.lexsort((x, y), axis=1)
        array([[2, 3, 0, 1],
               [2, 0, 3, 1],
               [1, 0, 3, 2]])

        Each row of the result is what we would expect if we were to perform
        `lexsort` on the corresponding row of the keys:

        >>> for i in range(3):
        ...     print(np.lexsort((x[i], y[i])))
        [2 3 0 1]
        [2 0 3 1]
        [1 0 3 2]

    linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)
        Return evenly spaced numbers over a specified interval.

        Returns `num` evenly spaced samples, calculated over the
        interval [`start`, `stop`].

        The endpoint of the interval can optionally be excluded.

        .. versionchanged:: 1.16.0
            Non-scalar `start` and `stop` are now supported.

        .. versionchanged:: 1.20.0
            Values are rounded towards ``-inf`` instead of ``0`` when an
            integer ``dtype`` is specified. The old behavior can
            still be obtained with ``np.linspace(start, stop, num).astype(int)``

        Parameters
        ----------
        start : array_like
            The starting value of the sequence.
        stop : array_like
            The end value of the sequence, unless `endpoint` is set to False.
            In that case, the sequence consists of all but the last of ``num + 1``
            evenly spaced samples, so that `stop` is excluded.  Note that the step
            size changes when `endpoint` is False.
        num : int, optional
            Number of samples to generate. Default is 50. Must be non-negative.
        endpoint : bool, optional
            If True, `stop` is the last sample. Otherwise, it is not included.
            Default is True.
        retstep : bool, optional
            If True, return (`samples`, `step`), where `step` is the spacing
            between samples.
        dtype : dtype, optional
            The type of the output array.  If `dtype` is not given, the data type
            is inferred from `start` and `stop`. The inferred dtype will never be
            an integer; `float` is chosen even if the arguments would produce an
            array of integers.

            .. versionadded:: 1.9.0
        axis : int, optional
            The axis in the result to store the samples.  Relevant only if start
            or stop are array-like.  By default (0), the samples will be along a
            new axis inserted at the beginning. Use -1 to get an axis at the end.

            .. versionadded:: 1.16.0
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0

        Returns
        -------
        samples : ndarray
            There are `num` equally spaced samples in the closed interval
            ``[start, stop]`` or the half-open interval ``[start, stop)``
            (depending on whether `endpoint` is True or False).
        step : float, optional
            Only returned if `retstep` is True

            Size of spacing between samples.


        See Also
        --------
        arange : Similar to `linspace`, but uses a step size (instead of the
                 number of samples).
        geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
                    scale (a geometric progression).
        logspace : Similar to `geomspace`, but with the end points specified as
                   logarithms.
        :ref:`how-to-partition`

        Examples
        --------
        >>> import numpy as np
        >>> np.linspace(2.0, 3.0, num=5)
        array([2.  , 2.25, 2.5 , 2.75, 3.  ])
        >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
        array([2. ,  2.2,  2.4,  2.6,  2.8])
        >>> np.linspace(2.0, 3.0, num=5, retstep=True)
        (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

        Graphical illustration:

        >>> import matplotlib.pyplot as plt
        >>> N = 8
        >>> y = np.zeros(N)
        >>> x1 = np.linspace(0, 10, N, endpoint=True)
        >>> x2 = np.linspace(0, 10, N, endpoint=False)
        >>> plt.plot(x1, y, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.plot(x2, y + 0.5, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.ylim([-0.5, 1])
        (-0.5, 1)
        >>> plt.show()

    load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=10000)
        Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.

        .. warning:: Loading files that contain object arrays uses the ``pickle``
                     module, which is not secure against erroneous or maliciously
                     constructed data. Consider passing ``allow_pickle=False`` to
                     load data that is known not to contain object arrays for the
                     safer handling of untrusted sources.

        Parameters
        ----------
        file : file-like object, string, or pathlib.Path
            The file to read. File-like objects must support the
            ``seek()`` and ``read()`` methods and must always
            be opened in binary mode.  Pickled files require that the
            file-like object support the ``readline()`` method as well.
        mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
            If not None, then memory-map the file, using the given mode (see
            `numpy.memmap` for a detailed description of the modes).  A
            memory-mapped array is kept on disk. However, it can be accessed
            and sliced like any ndarray.  Memory mapping is especially useful
            for accessing small fragments of large files without reading the
            entire file into memory.
        allow_pickle : bool, optional
            Allow loading pickled object arrays stored in npy files. Reasons for
            disallowing pickles include security, as loading pickled data can
            execute arbitrary code. If pickles are disallowed, loading object
            arrays will fail. Default: False

            .. versionchanged:: 1.16.3
                Made default False in response to CVE-2019-6446.

        fix_imports : bool, optional
            Only useful when loading Python 2 generated pickled files on Python 3,
            which includes npy/npz files containing object arrays. If `fix_imports`
            is True, pickle will try to map the old Python 2 names to the new names
            used in Python 3.
        encoding : str, optional
            What encoding to use when reading Python 2 strings. Only useful when
            loading Python 2 generated pickled files in Python 3, which includes
            npy/npz files containing object arrays. Values other than 'latin1',
            'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
            data. Default: 'ASCII'
        max_header_size : int, optional
            Maximum allowed size of the header.  Large headers may not be safe
            to load securely and thus require explicitly passing a larger value.
            See :py:func:`ast.literal_eval()` for details.
            This option is ignored when `allow_pickle` is passed.  In that case
            the file is by definition trusted and the limit is unnecessary.

        Returns
        -------
        result : array, tuple, dict, etc.
            Data stored in the file. For ``.npz`` files, the returned instance
            of NpzFile class must be closed to avoid leaking file descriptors.

        Raises
        ------
        OSError
            If the input file does not exist or cannot be read.
        UnpicklingError
            If ``allow_pickle=True``, but the file cannot be loaded as a pickle.
        ValueError
            The file contains an object array, but ``allow_pickle=False`` given.
        EOFError
            When calling ``np.load`` multiple times on the same file handle,
            if all data has already been read

        See Also
        --------
        save, savez, savez_compressed, loadtxt
        memmap : Create a memory-map to an array stored in a file on disk.
        lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.

        Notes
        -----
        - If the file contains pickle data, then whatever object is stored
          in the pickle is returned.
        - If the file is a ``.npy`` file, then a single array is returned.
        - If the file is a ``.npz`` file, then a dictionary-like object is
          returned, containing ``{filename: array}`` key-value pairs, one for
          each file in the archive.
        - If the file is a ``.npz`` file, the returned value supports the
          context manager protocol in a similar fashion to the open function::

            with load('foo.npz') as data:
                a = data['a']

          The underlying file descriptor is closed when exiting the 'with'
          block.

        Examples
        --------
        >>> import numpy as np

        Store data to disk, and load it again:

        >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
        >>> np.load('/tmp/123.npy')
        array([[1, 2, 3],
               [4, 5, 6]])

        Store compressed data to disk, and load it again:

        >>> a=np.array([[1, 2, 3], [4, 5, 6]])
        >>> b=np.array([1, 2])
        >>> np.savez('/tmp/123.npz', a=a, b=b)
        >>> data = np.load('/tmp/123.npz')
        >>> data['a']
        array([[1, 2, 3],
               [4, 5, 6]])
        >>> data['b']
        array([1, 2])
        >>> data.close()

        Mem-map the stored array, and then access the second row
        directly from disk:

        >>> X = np.load('/tmp/123.npy', mmap_mode='r')
        >>> X[1, :]
        memmap([4, 5, 6])

    loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=None, max_rows=None, *, quotechar=None, like=None)
        Load data from a text file.

        Parameters
        ----------
        fname : file, str, pathlib.Path, list of str, generator
            File, filename, list, or generator to read.  If the filename
            extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
            that generators must return bytes or strings. The strings
            in a list or produced by a generator are treated as lines.
        dtype : data-type, optional
            Data-type of the resulting array; default: float.  If this is a
            structured data-type, the resulting array will be 1-dimensional, and
            each row will be interpreted as an element of the array.  In this
            case, the number of columns used must match the number of fields in
            the data-type.
        comments : str or sequence of str or None, optional
            The characters or list of characters used to indicate the start of a
            comment. None implies no comments. For backwards compatibility, byte
            strings will be decoded as 'latin1'. The default is '#'.
        delimiter : str, optional
            The character used to separate the values. For backwards compatibility,
            byte strings will be decoded as 'latin1'. The default is whitespace.

            .. versionchanged:: 1.23.0
               Only single character delimiters are supported. Newline characters
               cannot be used as the delimiter.

        converters : dict or callable, optional
            Converter functions to customize value parsing. If `converters` is
            callable, the function is applied to all columns, else it must be a
            dict that maps column number to a parser function.
            See examples for further details.
            Default: None.

            .. versionchanged:: 1.23.0
               The ability to pass a single callable to be applied to all columns
               was added.

        skiprows : int, optional
            Skip the first `skiprows` lines, including comments; default: 0.
        usecols : int or sequence, optional
            Which columns to read, with 0 being the first. For example,
            ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
            The default, None, results in all columns being read.

            .. versionchanged:: 1.11.0
                When a single column has to be read it is possible to use
                an integer instead of a tuple. E.g ``usecols = 3`` reads the
                fourth column the same way as ``usecols = (3,)`` would.
        unpack : bool, optional
            If True, the returned array is transposed, so that arguments may be
            unpacked using ``x, y, z = loadtxt(...)``.  When used with a
            structured data-type, arrays are returned for each field.
            Default is False.
        ndmin : int, optional
            The returned array will have at least `ndmin` dimensions.
            Otherwise mono-dimensional axes will be squeezed.
            Legal values: 0 (default), 1 or 2.

            .. versionadded:: 1.6.0
        encoding : str, optional
            Encoding used to decode the inputfile. Does not apply to input streams.
            The special value 'bytes' enables backward compatibility workarounds
            that ensures you receive byte arrays as results if possible and passes
            'latin1' encoded strings to converters. Override this value to receive
            unicode arrays and pass strings as input to converters.  If set to None
            the system default is used. The default value is 'bytes'.

            .. versionadded:: 1.14.0
            .. versionchanged:: 2.0
                Before NumPy 2, the default was ``'bytes'`` for Python 2
                compatibility. The default is now ``None``.

        max_rows : int, optional
            Read `max_rows` rows of content after `skiprows` lines. The default is
            to read all the rows. Note that empty rows containing no data such as
            empty lines and comment lines are not counted towards `max_rows`,
            while such lines are counted in `skiprows`.

            .. versionadded:: 1.16.0

            .. versionchanged:: 1.23.0
                Lines containing no data, including comment lines (e.g., lines
                starting with '#' or as specified via `comments`) are not counted
                towards `max_rows`.
        quotechar : unicode character or None, optional
            The character used to denote the start and end of a quoted item.
            Occurrences of the delimiter or comment characters are ignored within
            a quoted item. The default value is ``quotechar=None``, which means
            quoting support is disabled.

            If two consecutive instances of `quotechar` are found within a quoted
            field, the first is treated as an escape character. See examples.

            .. versionadded:: 1.23.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Data read from the text file.

        See Also
        --------
        load, fromstring, fromregex
        genfromtxt : Load data with missing values handled as specified.
        scipy.io.loadmat : reads MATLAB data files

        Notes
        -----
        This function aims to be a fast reader for simply formatted files.  The
        `genfromtxt` function provides more sophisticated handling of, e.g.,
        lines with missing values.

        Each row in the input text file must have the same number of values to be
        able to read all values. If all rows do not have same number of values, a
        subset of up to n columns (where n is the least number of values present
        in all rows) can be read by specifying the columns via `usecols`.

        .. versionadded:: 1.10.0

        The strings produced by the Python float.hex method can be used as
        input for floats.

        Examples
        --------
        >>> import numpy as np
        >>> from io import StringIO   # StringIO behaves like a file object
        >>> c = StringIO("0 1\n2 3")
        >>> np.loadtxt(c)
        array([[0., 1.],
               [2., 3.]])

        >>> d = StringIO("M 21 72\nF 35 58")
        >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
        ...                      'formats': ('S1', 'i4', 'f4')})
        array([(b'M', 21, 72.), (b'F', 35, 58.)],
              dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])

        >>> c = StringIO("1,0,2\n3,0,4")
        >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
        >>> x
        array([1., 3.])
        >>> y
        array([2., 4.])

        The `converters` argument is used to specify functions to preprocess the
        text prior to parsing. `converters` can be a dictionary that maps
        preprocessing functions to each column:

        >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")
        >>> conv = {
        ...     0: lambda x: np.floor(float(x)),  # conversion fn for column 0
        ...     1: lambda x: np.ceil(float(x)),  # conversion fn for column 1
        ... }
        >>> np.loadtxt(s, delimiter=",", converters=conv)
        array([[1., 3.],
               [3., 5.]])

        `converters` can be a callable instead of a dictionary, in which case it
        is applied to all columns:

        >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")
        >>> import functools
        >>> conv = functools.partial(int, base=16)
        >>> np.loadtxt(s, converters=conv)
        array([[222., 173.],
               [192., 222.]])

        This example shows how `converters` can be used to convert a field
        with a trailing minus sign into a negative number.

        >>> s = StringIO("10.01 31.25-\n19.22 64.31\n17.57- 63.94")
        >>> def conv(fld):
        ...     return -float(fld[:-1]) if fld.endswith("-") else float(fld)
        ...
        >>> np.loadtxt(s, converters=conv)
        array([[ 10.01, -31.25],
               [ 19.22,  64.31],
               [-17.57,  63.94]])

        Using a callable as the converter can be particularly useful for handling
        values with different formatting, e.g. floats with underscores:

        >>> s = StringIO("1 2.7 100_000")
        >>> np.loadtxt(s, converters=float)
        array([1.e+00, 2.7e+00, 1.e+05])

        This idea can be extended to automatically handle values specified in
        many different formats, such as hex values:

        >>> def conv(val):
        ...     try:
        ...         return float(val)
        ...     except ValueError:
        ...         return float.fromhex(val)
        >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
        >>> np.loadtxt(s, delimiter=",", converters=conv)
        array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])

        Or a format where the ``-`` sign comes after the number:

        >>> s = StringIO("10.01 31.25-\n19.22 64.31\n17.57- 63.94")
        >>> conv = lambda x: -float(x[:-1]) if x.endswith("-") else float(x)
        >>> np.loadtxt(s, converters=conv)
        array([[ 10.01, -31.25],
               [ 19.22,  64.31],
               [-17.57,  63.94]])

        Support for quoted fields is enabled with the `quotechar` parameter.
        Comment and delimiter characters are ignored when they appear within a
        quoted item delineated by `quotechar`:

        >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')
        >>> dtype = np.dtype([("label", "U12"), ("value", float)])
        >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
        array([('alpha, #42', 10.), ('beta, #64',  2.)],
              dtype=[('label', '<U12'), ('value', '<f8')])

        Quoted fields can be separated by multiple whitespace characters:

        >>> s = StringIO('"alpha, #42"       10.0\n"beta, #64" 2.0\n')
        >>> dtype = np.dtype([("label", "U12"), ("value", float)])
        >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
        array([('alpha, #42', 10.), ('beta, #64',  2.)],
              dtype=[('label', '<U12'), ('value', '<f8')])

        Two consecutive quote characters within a quoted field are treated as a
        single escaped character:

        >>> s = StringIO('"Hello, my name is ""Monty""!"')
        >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
        array('Hello, my name is "Monty"!', dtype='<U26')

        Read subset of columns when all rows do not contain equal number of values:

        >>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")
        >>> np.loadtxt(d, usecols=(0, 1))
        array([[ 1.,  2.],
               [ 2.,  4.],
               [ 3.,  9.],
               [ 4., 16.]])

    logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
        Return numbers spaced evenly on a log scale.

        In linear space, the sequence starts at ``base ** start``
        (`base` to the power of `start`) and ends with ``base ** stop``
        (see `endpoint` below).

        .. versionchanged:: 1.16.0
            Non-scalar `start` and `stop` are now supported.

        .. versionchanged:: 1.25.0
            Non-scalar 'base` is now supported

        Parameters
        ----------
        start : array_like
            ``base ** start`` is the starting value of the sequence.
        stop : array_like
            ``base ** stop`` is the final value of the sequence, unless `endpoint`
            is False.  In that case, ``num + 1`` values are spaced over the
            interval in log-space, of which all but the last (a sequence of
            length `num`) are returned.
        num : integer, optional
            Number of samples to generate.  Default is 50.
        endpoint : boolean, optional
            If true, `stop` is the last sample. Otherwise, it is not included.
            Default is True.
        base : array_like, optional
            The base of the log space. The step size between the elements in
            ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
            Default is 10.0.
        dtype : dtype
            The type of the output array.  If `dtype` is not given, the data type
            is inferred from `start` and `stop`. The inferred type will never be
            an integer; `float` is chosen even if the arguments would produce an
            array of integers.
        axis : int, optional
            The axis in the result to store the samples.  Relevant only if start,
            stop, or base are array-like.  By default (0), the samples will be
            along a new axis inserted at the beginning. Use -1 to get an axis at
            the end.

            .. versionadded:: 1.16.0


        Returns
        -------
        samples : ndarray
            `num` samples, equally spaced on a log scale.

        See Also
        --------
        arange : Similar to linspace, with the step size specified instead of the
                 number of samples. Note that, when used with a float endpoint, the
                 endpoint may or may not be included.
        linspace : Similar to logspace, but with the samples uniformly distributed
                   in linear space, instead of log space.
        geomspace : Similar to logspace, but with endpoints specified directly.
        :ref:`how-to-partition`

        Notes
        -----
        If base is a scalar, logspace is equivalent to the code

        >>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
        ... # doctest: +SKIP
        >>> power(base, y).astype(dtype)
        ... # doctest: +SKIP

        Examples
        --------
        >>> import numpy as np
        >>> np.logspace(2.0, 3.0, num=4)
        array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
        >>> np.logspace(2.0, 3.0, num=4, endpoint=False)
        array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
        >>> np.logspace(2.0, 3.0, num=4, base=2.0)
        array([4.        ,  5.0396842 ,  6.34960421,  8.        ])
        >>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1)
        array([[ 4.        ,  5.0396842 ,  6.34960421,  8.        ],
               [ 9.        , 12.98024613, 18.72075441, 27.        ]])

        Graphical illustration:

        >>> import matplotlib.pyplot as plt
        >>> N = 10
        >>> x1 = np.logspace(0.1, 1, N, endpoint=True)
        >>> x2 = np.logspace(0.1, 1, N, endpoint=False)
        >>> y = np.zeros(N)
        >>> plt.plot(x1, y, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.plot(x2, y + 0.5, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.ylim([-0.5, 1])
        (-0.5, 1)
        >>> plt.show()

    mask_indices(n, mask_func, k=0)
        Return the indices to access (n, n) arrays, given a masking function.

        Assume `mask_func` is a function that, for a square array a of size
        ``(n, n)`` with a possible offset argument `k`, when called as
        ``mask_func(a, k)`` returns a new array with zeros in certain locations
        (functions like `triu` or `tril` do precisely this). Then this function
        returns the indices where the non-zero values would be located.

        Parameters
        ----------
        n : int
            The returned indices will be valid to access arrays of shape (n, n).
        mask_func : callable
            A function whose call signature is similar to that of `triu`, `tril`.
            That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
            `k` is an optional argument to the function.
        k : scalar
            An optional argument which is passed through to `mask_func`. Functions
            like `triu`, `tril` take a second argument that is interpreted as an
            offset.

        Returns
        -------
        indices : tuple of arrays.
            The `n` arrays of indices corresponding to the locations where
            ``mask_func(np.ones((n, n)), k)`` is True.

        See Also
        --------
        triu, tril, triu_indices, tril_indices

        Notes
        -----
        .. versionadded:: 1.4.0

        Examples
        --------
        >>> import numpy as np

        These are the indices that would allow you to access the upper triangular
        part of any 3x3 array:

        >>> iu = np.mask_indices(3, np.triu)

        For example, if `a` is a 3x3 array:

        >>> a = np.arange(9).reshape(3, 3)
        >>> a
        array([[0, 1, 2],
               [3, 4, 5],
               [6, 7, 8]])
        >>> a[iu]
        array([0, 1, 2, 4, 5, 8])

        An offset can be passed also to the masking function.  This gets us the
        indices starting on the first diagonal right of the main one:

        >>> iu1 = np.mask_indices(3, np.triu, 1)

        with which we now extract only three elements:

        >>> a[iu1]
        array([1, 2, 5])

    matrix_transpose(x, /)
        Transposes a matrix (or a stack of matrices) ``x``.

        This function is Array API compatible.

        Parameters
        ----------
        x : array_like
            Input array having shape (..., M, N) and whose two innermost
            dimensions form ``MxN`` matrices.

        Returns
        -------
        out : ndarray
            An array containing the transpose for each matrix and having shape
            (..., N, M).

        See Also
        --------
        transpose : Generic transpose method.

        Examples
        --------
        >>> import numpy as np
        >>> np.matrix_transpose([[1, 2], [3, 4]])
        array([[1, 3],
               [2, 4]])

        >>> np.matrix_transpose([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
        array([[[1, 3],
                [2, 4]],
               [[5, 7],
                [6, 8]]])

    max(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        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 :ref:`ufuncs-output-type` 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 ``max`` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.

        initial : scalar, optional
            The minimum value of an output element. Must be present to allow
            computation on empty slice. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.15.0

        where : array_like of bool, optional
            Elements to compare for the maximum. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.17.0

        Returns
        -------
        max : ndarray or scalar
            Maximum of `a`. If `axis` is None, the result is a scalar value.
            If `axis` is an int, the result is an array of dimension
            ``a.ndim - 1``. If `axis` is a tuple, the result is an array of
            dimension ``a.ndim - len(axis)``.

        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 `~numpy.max` for element-wise comparison of 2 arrays; when
        ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
        ``max(a, axis=0)``.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(4).reshape((2,2))
        >>> a
        array([[0, 1],
               [2, 3]])
        >>> np.max(a)           # Maximum of the flattened array
        3
        >>> np.max(a, axis=0)   # Maxima along the first axis
        array([2, 3])
        >>> np.max(a, axis=1)   # Maxima along the second axis
        array([1, 3])
        >>> np.max(a, where=[False, True], initial=-1, axis=0)
        array([-1,  3])
        >>> b = np.arange(5, dtype=float)
        >>> b[2] = np.nan
        >>> np.max(b)
        np.float64(nan)
        >>> np.max(b, where=~np.isnan(b), initial=-1)
        4.0
        >>> np.nanmax(b)
        4.0

        You can use an initial value to compute the maximum of an empty slice, or
        to initialize it to a different value:

        >>> np.max([[-50], [10]], axis=-1, initial=0)
        array([ 0, 10])

        Notice that the initial value is used as one of the elements for which the
        maximum is determined, unlike for the default argument Python's max
        function, which is only used for empty iterables.

        >>> np.max([5], initial=6)
        6
        >>> max([5], default=6)
        5

    may_share_memory(...)
        may_share_memory(a, b, /, max_work=None)

        Determine if two arrays might share memory

        A return of True does not necessarily mean that the two arrays
        share any element.  It just means that they *might*.

        Only the memory bounds of a and b are checked by default.

        Parameters
        ----------
        a, b : ndarray
            Input arrays
        max_work : int, optional
            Effort to spend on solving the overlap problem.  See
            `shares_memory` for details.  Default for ``may_share_memory``
            is to do a bounds check.

        Returns
        -------
        out : bool

        See Also
        --------
        shares_memory

        Examples
        --------
        >>> import numpy as np
        >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
        False
        >>> x = np.zeros([3, 4])
        >>> np.may_share_memory(x[:,0], x[:,1])
        True

    mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)
        Compute the arithmetic mean along the specified axis.

        Returns the average of the array elements.  The average is taken over
        the flattened array by default, otherwise over the specified axis.
        `float64` intermediate and return values are used for integer inputs.

        Parameters
        ----------
        a : array_like
            Array containing numbers whose mean is desired. If `a` is not an
            array, a conversion is attempted.
        axis : None or int or tuple of ints, optional
            Axis or axes along which the means are computed. The default is to
            compute the mean of the flattened array.

            .. versionadded:: 1.7.0

            If this is a tuple of ints, a mean is performed over multiple axes,
            instead of a single axis or all the axes as before.
        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.
        out : ndarray, optional
            Alternate output array in which to place the result.  The default
            is ``None``; if provided, it must have the same shape as the
            expected output, but the type will be cast if necessary.
            See :ref:`ufuncs-output-type` for more details.
            See :ref:`ufuncs-output-type` 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 `mean` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.

        where : array_like of bool, optional
            Elements to include in the mean. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.20.0

        Returns
        -------
        m : ndarray, see dtype parameter above
            If `out=None`, returns a new array containing the mean values,
            otherwise a reference to the output array is returned.

        See Also
        --------
        average : Weighted average
        std, var, nanmean, nanstd, nanvar

        Notes
        -----
        The arithmetic mean is the sum of the elements along the axis divided
        by the number of elements.

        Note that for floating-point input, the mean is computed using the
        same precision the input has.  Depending on the input data, this can
        cause the results to be inaccurate, especially for `float32` (see
        example below).  Specifying a higher-precision accumulator using the
        `dtype` keyword can alleviate this issue.

        By default, `float16` results are computed using `float32` intermediates
        for extra precision.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> np.mean(a)
        2.5
        >>> np.mean(a, axis=0)
        array([2., 3.])
        >>> np.mean(a, axis=1)
        array([1.5, 3.5])

        In single precision, `mean` can be inaccurate:

        >>> a = np.zeros((2, 512*512), dtype=np.float32)
        >>> a[0, :] = 1.0
        >>> a[1, :] = 0.1
        >>> np.mean(a)
        0.54999924

        Computing the mean in float64 is more accurate:

        >>> np.mean(a, dtype=np.float64)
        0.55000000074505806 # may vary

        Specifying a where argument:

        >>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])
        >>> np.mean(a)
        12.0
        >>> np.mean(a, where=[[True], [False], [False]])
        9.0

    median(a, axis=None, out=None, overwrite_input=False, keepdims=False)
        Compute the median along the specified axis.

        Returns the median of the array elements.

        Parameters
        ----------
        a : array_like
            Input array or object that can be converted to an array.
        axis : {int, sequence of int, None}, optional
            Axis or axes along which the medians are computed. The default,
            axis=None, will compute the median along a flattened version of
            the array.

            .. versionadded:: 1.9.0

            If a sequence of axes, the array is first flattened along the
            given axes, then the median is computed along the resulting
            flattened axis.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output,
            but the type (of the output) will be cast if necessary.
        overwrite_input : bool, optional
           If True, then allow use of memory of input array `a` for
           calculations. The input array will be modified by the call to
           `median`. This will save memory when you do not need to preserve
           the contents of the input array. Treat the input as undefined,
           but it will probably be fully or partially sorted. Default is
           False. If `overwrite_input` is ``True`` and `a` is not already an
           `ndarray`, an error will be raised.
        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 `arr`.

            .. versionadded:: 1.9.0

        Returns
        -------
        median : ndarray
            A new array holding the result. If the input contains integers
            or floats smaller than ``float64``, then the output data-type is
            ``np.float64``.  Otherwise, the data-type of the output is the
            same as that of the input. If `out` is specified, that array is
            returned instead.

        See Also
        --------
        mean, percentile

        Notes
        -----
        Given a vector ``V`` of length ``N``, the median of ``V`` is the
        middle value of a sorted copy of ``V``, ``V_sorted`` - i
        e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
        two middle values of ``V_sorted`` when ``N`` is even.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[10, 7, 4], [3, 2, 1]])
        >>> a
        array([[10,  7,  4],
               [ 3,  2,  1]])
        >>> np.median(a)
        np.float64(3.5)
        >>> np.median(a, axis=0)
        array([6.5, 4.5, 2.5])
        >>> np.median(a, axis=1)
        array([7.,  2.])
        >>> np.median(a, axis=(0, 1))
        np.float64(3.5)
        >>> m = np.median(a, axis=0)
        >>> out = np.zeros_like(m)
        >>> np.median(a, axis=0, out=m)
        array([6.5,  4.5,  2.5])
        >>> m
        array([6.5,  4.5,  2.5])
        >>> b = a.copy()
        >>> np.median(b, axis=1, overwrite_input=True)
        array([7.,  2.])
        >>> assert not np.all(a==b)
        >>> b = a.copy()
        >>> np.median(b, axis=None, overwrite_input=True)
        np.float64(3.5)
        >>> assert not np.all(a==b)

    meshgrid(*xi, copy=True, sparse=False, indexing='xy')
        Return a tuple of coordinate matrices from coordinate vectors.

        Make N-D coordinate arrays for vectorized evaluations of
        N-D scalar/vector fields over N-D grids, given
        one-dimensional coordinate arrays x1, x2,..., xn.

        .. versionchanged:: 1.9
           1-D and 0-D cases are allowed.

        Parameters
        ----------
        x1, x2,..., xn : array_like
            1-D arrays representing the coordinates of a grid.
        indexing : {'xy', 'ij'}, optional
            Cartesian ('xy', default) or matrix ('ij') indexing of output.
            See Notes for more details.

            .. versionadded:: 1.7.0
        sparse : bool, optional
            If True the shape of the returned coordinate array for dimension *i*
            is reduced from ``(N1, ..., Ni, ... Nn)`` to
            ``(1, ..., 1, Ni, 1, ..., 1)``.  These sparse coordinate grids are
            intended to be use with :ref:`basics.broadcasting`.  When all
            coordinates are used in an expression, broadcasting still leads to a
            fully-dimensonal result array.

            Default is False.

            .. versionadded:: 1.7.0
        copy : bool, optional
            If False, a view into the original arrays are returned in order to
            conserve memory.  Default is True.  Please note that
            ``sparse=False, copy=False`` will likely return non-contiguous
            arrays.  Furthermore, more than one element of a broadcast array
            may refer to a single memory location.  If you need to write to the
            arrays, make copies first.

            .. versionadded:: 1.7.0

        Returns
        -------
        X1, X2,..., XN : tuple of ndarrays
            For vectors `x1`, `x2`,..., `xn` with lengths ``Ni=len(xi)``,
            returns ``(N1, N2, N3,..., Nn)`` shaped arrays if indexing='ij'
            or ``(N2, N1, N3,..., Nn)`` shaped arrays if indexing='xy'
            with the elements of `xi` repeated to fill the matrix along
            the first dimension for `x1`, the second for `x2` and so on.

        Notes
        -----
        This function supports both indexing conventions through the indexing
        keyword argument.  Giving the string 'ij' returns a meshgrid with
        matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
        In the 2-D case with inputs of length M and N, the outputs are of shape
        (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
        with inputs of length M, N and P, outputs are of shape (N, M, P) for
        'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
        illustrated by the following code snippet::

            xv, yv = np.meshgrid(x, y, indexing='ij')
            for i in range(nx):
                for j in range(ny):
                    # treat xv[i,j], yv[i,j]

            xv, yv = np.meshgrid(x, y, indexing='xy')
            for i in range(nx):
                for j in range(ny):
                    # treat xv[j,i], yv[j,i]

        In the 1-D and 0-D case, the indexing and sparse keywords have no effect.

        See Also
        --------
        mgrid : Construct a multi-dimensional "meshgrid" using indexing notation.
        ogrid : Construct an open multi-dimensional "meshgrid" using indexing
                notation.
        :ref:`how-to-index`

        Examples
        --------
        >>> import numpy as np
        >>> nx, ny = (3, 2)
        >>> x = np.linspace(0, 1, nx)
        >>> y = np.linspace(0, 1, ny)
        >>> xv, yv = np.meshgrid(x, y)
        >>> xv
        array([[0. , 0.5, 1. ],
               [0. , 0.5, 1. ]])
        >>> yv
        array([[0.,  0.,  0.],
               [1.,  1.,  1.]])

        The result of `meshgrid` is a coordinate grid:

        >>> import matplotlib.pyplot as plt
        >>> plt.plot(xv, yv, marker='o', color='k', linestyle='none')
        >>> plt.show()

        You can create sparse output arrays to save memory and computation time.

        >>> xv, yv = np.meshgrid(x, y, sparse=True)
        >>> xv
        array([[0. ,  0.5,  1. ]])
        >>> yv
        array([[0.],
               [1.]])

        `meshgrid` is very useful to evaluate functions on a grid. If the
        function depends on all coordinates, both dense and sparse outputs can be
        used.

        >>> x = np.linspace(-5, 5, 101)
        >>> y = np.linspace(-5, 5, 101)
        >>> # full coordinate arrays
        >>> xx, yy = np.meshgrid(x, y)
        >>> zz = np.sqrt(xx**2 + yy**2)
        >>> xx.shape, yy.shape, zz.shape
        ((101, 101), (101, 101), (101, 101))
        >>> # sparse coordinate arrays
        >>> xs, ys = np.meshgrid(x, y, sparse=True)
        >>> zs = np.sqrt(xs**2 + ys**2)
        >>> xs.shape, ys.shape, zs.shape
        ((1, 101), (101, 1), (101, 101))
        >>> np.array_equal(zz, zs)
        True

        >>> h = plt.contourf(x, y, zs)
        >>> plt.axis('scaled')
        >>> plt.colorbar()
        >>> plt.show()

    min(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the minimum of an array or minimum 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 minimum 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 :ref:`ufuncs-output-type` 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 ``min`` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.

        initial : scalar, optional
            The maximum value of an output element. Must be present to allow
            computation on empty slice. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.15.0

        where : array_like of bool, optional
            Elements to compare for the minimum. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.17.0

        Returns
        -------
        min : ndarray or scalar
            Minimum of `a`. If `axis` is None, the result is a scalar value.
            If `axis` is an int, the result is an array of dimension
            ``a.ndim - 1``.  If `axis` is a tuple, the result is an array of
            dimension ``a.ndim - len(axis)``.

        See Also
        --------
        amax :
            The maximum value of an array along a given axis, propagating any NaNs.
        nanmin :
            The minimum value of an array along a given axis, ignoring any NaNs.
        minimum :
            Element-wise minimum of two arrays, propagating any NaNs.
        fmin :
            Element-wise minimum of two arrays, ignoring any NaNs.
        argmin :
            Return the indices of the minimum values.

        nanmax, maximum, fmax

        Notes
        -----
        NaN values are propagated, that is if at least one item is NaN, the
        corresponding min value will be NaN as well. To ignore NaN values
        (MATLAB behavior), please use nanmin.

        Don't use `~numpy.min` for element-wise comparison of 2 arrays; when
        ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
        ``min(a, axis=0)``.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(4).reshape((2,2))
        >>> a
        array([[0, 1],
               [2, 3]])
        >>> np.min(a)           # Minimum of the flattened array
        0
        >>> np.min(a, axis=0)   # Minima along the first axis
        array([0, 1])
        >>> np.min(a, axis=1)   # Minima along the second axis
        array([0, 2])
        >>> np.min(a, where=[False, True], initial=10, axis=0)
        array([10,  1])

        >>> b = np.arange(5, dtype=float)
        >>> b[2] = np.nan
        >>> np.min(b)
        np.float64(nan)
        >>> np.min(b, where=~np.isnan(b), initial=10)
        0.0
        >>> np.nanmin(b)
        0.0

        >>> np.min([[-50], [10]], axis=-1, initial=0)
        array([-50,   0])

        Notice that the initial value is used as one of the elements for which the
        minimum is determined, unlike for the default argument Python's max
        function, which is only used for empty iterables.

        Notice that this isn't the same as Python's ``default`` argument.

        >>> np.min([6], initial=5)
        5
        >>> min([6], default=5)
        6

    min_scalar_type(...)
        min_scalar_type(a, /)

        For scalar ``a``, returns the data type with the smallest size
        and smallest scalar kind which can hold its value.  For non-scalar
        array ``a``, returns the vector's dtype unmodified.

        Floating point values are not demoted to integers,
        and complex values are not demoted to floats.

        Parameters
        ----------
        a : scalar or array_like
            The value whose minimal data type is to be found.

        Returns
        -------
        out : dtype
            The minimal data type.

        Notes
        -----
        .. versionadded:: 1.6.0

        See Also
        --------
        result_type, promote_types, dtype, can_cast

        Examples
        --------
        >>> import numpy as np
        >>> np.min_scalar_type(10)
        dtype('uint8')

        >>> np.min_scalar_type(-260)
        dtype('int16')

        >>> np.min_scalar_type(3.1)
        dtype('float16')

        >>> np.min_scalar_type(1e50)
        dtype('float64')

        >>> np.min_scalar_type(np.arange(4,dtype='f8'))
        dtype('float64')

    mintypecode(typechars, typeset='GDFgdf', default='d')
        Return the character for the minimum-size type to which given types can
        be safely cast.

        The returned type character must represent the smallest size dtype such
        that an array of the returned type can handle the data from an array of
        all types in `typechars` (or if `typechars` is an array, then its
        dtype.char).

        Parameters
        ----------
        typechars : list of str or array_like
            If a list of strings, each string should represent a dtype.
            If array_like, the character representation of the array dtype is used.
        typeset : str or list of str, optional
            The set of characters that the returned character is chosen from.
            The default set is 'GDFgdf'.
        default : str, optional
            The default character, this is returned if none of the characters in
            `typechars` matches a character in `typeset`.

        Returns
        -------
        typechar : str
            The character representing the minimum-size type that was found.

        See Also
        --------
        dtype

        Examples
        --------
        >>> import numpy as np
        >>> np.mintypecode(['d', 'f', 'S'])
        'd'
        >>> x = np.array([1.1, 2-3.j])
        >>> np.mintypecode(x)
        'D'

        >>> np.mintypecode('abceh', default='G')
        'G'

    moveaxis(a, source, destination)
        Move axes of an array to new positions.

        Other axes remain in their original order.

        .. versionadded:: 1.11.0

        Parameters
        ----------
        a : np.ndarray
            The array whose axes should be reordered.
        source : int or sequence of int
            Original positions of the axes to move. These must be unique.
        destination : int or sequence of int
            Destination positions for each of the original axes. These must also be
            unique.

        Returns
        -------
        result : np.ndarray
            Array with moved axes. This array is a view of the input array.

        See Also
        --------
        transpose : Permute the dimensions of an array.
        swapaxes : Interchange two axes of an array.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.zeros((3, 4, 5))
        >>> np.moveaxis(x, 0, -1).shape
        (4, 5, 3)
        >>> np.moveaxis(x, -1, 0).shape
        (5, 3, 4)

        These all achieve the same result:

        >>> np.transpose(x).shape
        (5, 4, 3)
        >>> np.swapaxes(x, 0, -1).shape
        (5, 4, 3)
        >>> np.moveaxis(x, [0, 1], [-1, -2]).shape
        (5, 4, 3)
        >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
        (5, 4, 3)

    nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None)
        Replace NaN with zero and infinity with large finite numbers (default
        behaviour) or with the numbers defined by the user using the `nan`,
        `posinf` and/or `neginf` keywords.

        If `x` is inexact, NaN is replaced by zero or by the user defined value in
        `nan` keyword, infinity is replaced by the largest finite floating point
        values representable by ``x.dtype`` or by the user defined value in
        `posinf` keyword and -infinity is replaced by the most negative finite
        floating point values representable by ``x.dtype`` or by the user defined
        value in `neginf` keyword.

        For complex dtypes, the above is applied to each of the real and
        imaginary components of `x` separately.

        If `x` is not inexact, then no replacements are made.

        Parameters
        ----------
        x : scalar or array_like
            Input data.
        copy : bool, optional
            Whether to create a copy of `x` (True) or to replace values
            in-place (False). The in-place operation only occurs if
            casting to an array does not require a copy.
            Default is True.

            .. versionadded:: 1.13
        nan : int, float, optional
            Value to be used to fill NaN values. If no value is passed
            then NaN values will be replaced with 0.0.

            .. versionadded:: 1.17
        posinf : int, float, optional
            Value to be used to fill positive infinity values. If no value is
            passed then positive infinity values will be replaced with a very
            large number.

            .. versionadded:: 1.17
        neginf : int, float, optional
            Value to be used to fill negative infinity values. If no value is
            passed then negative infinity values will be replaced with a very
            small (or negative) number.

            .. versionadded:: 1.17



        Returns
        -------
        out : ndarray
            `x`, with the non-finite values replaced. If `copy` is False, this may
            be `x` itself.

        See Also
        --------
        isinf : Shows which elements are positive or negative infinity.
        isneginf : Shows which elements are negative infinity.
        isposinf : Shows which elements are positive infinity.
        isnan : Shows which elements are Not a Number (NaN).
        isfinite : Shows which elements are finite (not NaN, not infinity)

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754). This means that Not a Number is not equivalent to infinity.

        Examples
        --------
        >>> import numpy as np
        >>> np.nan_to_num(np.inf)
        1.7976931348623157e+308
        >>> np.nan_to_num(-np.inf)
        -1.7976931348623157e+308
        >>> np.nan_to_num(np.nan)
        0.0
        >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
        >>> np.nan_to_num(x)
        array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
               -1.28000000e+002,  1.28000000e+002])
        >>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
        array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03,
               -1.2800000e+02,  1.2800000e+02])
        >>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
        array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
             -1.28000000e+002,   1.28000000e+002])
        >>> np.nan_to_num(y)
        array([  1.79769313e+308 +0.00000000e+000j, # may vary
                 0.00000000e+000 +0.00000000e+000j,
                 0.00000000e+000 +1.79769313e+308j])
        >>> np.nan_to_num(y, nan=111111, posinf=222222)
        array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])

    nanargmax(a, axis=None, out=None, *, keepdims=<no value>)
        Return the indices of the maximum values in the specified axis ignoring
        NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
        results cannot be trusted if a slice contains only NaNs and -Infs.


        Parameters
        ----------
        a : array_like
            Input data.
        axis : int, optional
            Axis along which to operate.  By default flattened input is used.
        out : array, optional
            If provided, the result will be inserted into this array. It should
            be of the appropriate shape and dtype.

            .. versionadded:: 1.22.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 array.

            .. versionadded:: 1.22.0

        Returns
        -------
        index_array : ndarray
            An array of indices or a single index value.

        See Also
        --------
        argmax, nanargmin

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[np.nan, 4], [2, 3]])
        >>> np.argmax(a)
        0
        >>> np.nanargmax(a)
        1
        >>> np.nanargmax(a, axis=0)
        array([1, 0])
        >>> np.nanargmax(a, axis=1)
        array([1, 1])

    nanargmin(a, axis=None, out=None, *, keepdims=<no value>)
        Return the indices of the minimum values in the specified axis ignoring
        NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
        cannot be trusted if a slice contains only NaNs and Infs.

        Parameters
        ----------
        a : array_like
            Input data.
        axis : int, optional
            Axis along which to operate.  By default flattened input is used.
        out : array, optional
            If provided, the result will be inserted into this array. It should
            be of the appropriate shape and dtype.

            .. versionadded:: 1.22.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 array.

            .. versionadded:: 1.22.0

        Returns
        -------
        index_array : ndarray
            An array of indices or a single index value.

        See Also
        --------
        argmin, nanargmax

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[np.nan, 4], [2, 3]])
        >>> np.argmin(a)
        0
        >>> np.nanargmin(a)
        2
        >>> np.nanargmin(a, axis=0)
        array([1, 1])
        >>> np.nanargmin(a, axis=1)
        array([1, 0])

    nancumprod(a, axis=None, dtype=None, out=None)
        Return the cumulative product of array elements over a given axis treating Not a
        Numbers (NaNs) as one.  The cumulative product does not change when NaNs are
        encountered and leading NaNs are replaced by ones.

        Ones are returned for slices that are all-NaN or empty.

        .. versionadded:: 1.12.0

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int, optional
            Axis along which the cumulative product is computed.  By default
            the input is flattened.
        dtype : dtype, optional
            Type of the returned array, as well as of the accumulator in which
            the elements are multiplied.  If *dtype* is not specified, it
            defaults to the dtype of `a`, unless `a` has an integer dtype with
            a precision less than that of the default platform integer.  In
            that case, the default platform integer is used instead.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output
            but the type of the resulting values will be cast if necessary.

        Returns
        -------
        nancumprod : ndarray
            A new array holding the result is returned unless `out` is
            specified, in which case it is returned.

        See Also
        --------
        numpy.cumprod : Cumulative product across array propagating NaNs.
        isnan : Show which elements are NaN.

        Examples
        --------
        >>> import numpy as np
        >>> np.nancumprod(1)
        array([1])
        >>> np.nancumprod([1])
        array([1])
        >>> np.nancumprod([1, np.nan])
        array([1.,  1.])
        >>> a = np.array([[1, 2], [3, np.nan]])
        >>> np.nancumprod(a)
        array([1.,  2.,  6.,  6.])
        >>> np.nancumprod(a, axis=0)
        array([[1.,  2.],
               [3.,  2.]])
        >>> np.nancumprod(a, axis=1)
        array([[1.,  2.],
               [3.,  3.]])

    nancumsum(a, axis=None, dtype=None, out=None)
        Return the cumulative sum of array elements over a given axis treating Not a
        Numbers (NaNs) as zero.  The cumulative sum does not change when NaNs are
        encountered and leading NaNs are replaced by zeros.

        Zeros are returned for slices that are all-NaN or empty.

        .. versionadded:: 1.12.0

        Parameters
        ----------
        a : array_like
            Input array.
        axis : int, optional
            Axis along which the cumulative sum is computed. The default
            (None) is to compute the cumsum over the flattened array.
        dtype : dtype, optional
            Type of the returned array and of the accumulator in which the
            elements are summed.  If `dtype` is not specified, it defaults
            to the dtype of `a`, unless `a` has an integer dtype with a
            precision less than that of the default platform integer.  In
            that case, the default platform integer is used.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output
            but the type will be cast if necessary. See :ref:`ufuncs-output-type` for
            more details.

        Returns
        -------
        nancumsum : ndarray.
            A new array holding the result is returned unless `out` is
            specified, in which it is returned. The result has the same
            size as `a`, and the same shape as `a` if `axis` is not None
            or `a` is a 1-d array.

        See Also
        --------
        numpy.cumsum : Cumulative sum across array propagating NaNs.
        isnan : Show which elements are NaN.

        Examples
        --------
        >>> import numpy as np
        >>> np.nancumsum(1)
        array([1])
        >>> np.nancumsum([1])
        array([1])
        >>> np.nancumsum([1, np.nan])
        array([1.,  1.])
        >>> a = np.array([[1, 2], [3, np.nan]])
        >>> np.nancumsum(a)
        array([1.,  3.,  6.,  6.])
        >>> np.nancumsum(a, axis=0)
        array([[1.,  2.],
               [4.,  2.]])
        >>> np.nancumsum(a, axis=1)
        array([[1.,  3.],
               [3.,  3.]])

    nanmax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the maximum of an array or maximum along an axis, ignoring any
        NaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is
        raised and NaN is returned for that slice.

        Parameters
        ----------
        a : array_like
            Array containing numbers whose maximum is desired. If `a` is not an
            array, a conversion is attempted.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the maximum is computed. The default is to compute
            the maximum of the flattened array.
        out : ndarray, optional
            Alternate output array in which to place the result.  The default
            is ``None``; if provided, it must have the same shape as the
            expected output, but the type will be cast if necessary. See
            :ref:`ufuncs-output-type` for more details.

            .. versionadded:: 1.8.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 `a`.

            If the value is anything but the default, then
            `keepdims` will be passed through to the `max` method
            of sub-classes of `ndarray`.  If the sub-classes methods
            does not implement `keepdims` any exceptions will be raised.

            .. versionadded:: 1.8.0
        initial : scalar, optional
            The minimum value of an output element. Must be present to allow
            computation on empty slice. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.22.0
        where : array_like of bool, optional
            Elements to compare for the maximum. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.22.0

        Returns
        -------
        nanmax : ndarray
            An array with the same shape as `a`, with the specified axis removed.
            If `a` is a 0-d array, or if axis is None, an ndarray scalar is
            returned.  The same dtype as `a` is returned.

        See Also
        --------
        nanmin :
            The minimum value of an array along a given axis, ignoring any NaNs.
        amax :
            The maximum value of an array along a given axis, propagating any NaNs.
        fmax :
            Element-wise maximum of two arrays, ignoring any NaNs.
        maximum :
            Element-wise maximum of two arrays, propagating any NaNs.
        isnan :
            Shows which elements are Not a Number (NaN).
        isfinite:
            Shows which elements are neither NaN nor infinity.

        amin, fmin, minimum

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754). This means that Not a Number is not equivalent to infinity.
        Positive infinity is treated as a very large number and negative
        infinity is treated as a very small (i.e. negative) number.

        If the input has a integer type the function is equivalent to np.max.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, np.nan]])
        >>> np.nanmax(a)
        3.0
        >>> np.nanmax(a, axis=0)
        array([3.,  2.])
        >>> np.nanmax(a, axis=1)
        array([2.,  3.])

        When positive infinity and negative infinity are present:

        >>> np.nanmax([1, 2, np.nan, -np.inf])
        2.0
        >>> np.nanmax([1, 2, np.nan, np.inf])
        inf

    nanmean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)
        Compute the arithmetic mean along the specified axis, ignoring NaNs.

        Returns the average of the array elements.  The average is taken over
        the flattened array by default, otherwise over the specified axis.
        `float64` intermediate and return values are used for integer inputs.

        For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.

        .. versionadded:: 1.8.0

        Parameters
        ----------
        a : array_like
            Array containing numbers whose mean is desired. If `a` is not an
            array, a conversion is attempted.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the means are computed. The default is to compute
            the mean of the flattened array.
        dtype : data-type, optional
            Type to use in computing the mean.  For integer inputs, the default
            is `float64`; for inexact inputs, it is the same as the input
            dtype.
        out : ndarray, optional
            Alternate output array in which to place the result.  The default
            is ``None``; if provided, it must have the same shape as the
            expected output, but the type will be cast if necessary.
            See :ref:`ufuncs-output-type` 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 original `a`.

            If the value is anything but the default, then
            `keepdims` will be passed through to the `mean` or `sum` methods
            of sub-classes of `ndarray`.  If the sub-classes methods
            does not implement `keepdims` any exceptions will be raised.
        where : array_like of bool, optional
            Elements to include in the mean. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.22.0

        Returns
        -------
        m : ndarray, see dtype parameter above
            If `out=None`, returns a new array containing the mean values,
            otherwise a reference to the output array is returned. Nan is
            returned for slices that contain only NaNs.

        See Also
        --------
        average : Weighted average
        mean : Arithmetic mean taken while not ignoring NaNs
        var, nanvar

        Notes
        -----
        The arithmetic mean is the sum of the non-NaN elements along the axis
        divided by the number of non-NaN elements.

        Note that for floating-point input, the mean is computed using the same
        precision the input has.  Depending on the input data, this can cause
        the results to be inaccurate, especially for `float32`.  Specifying a
        higher-precision accumulator using the `dtype` keyword can alleviate
        this issue.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, np.nan], [3, 4]])
        >>> np.nanmean(a)
        2.6666666666666665
        >>> np.nanmean(a, axis=0)
        array([2.,  4.])
        >>> np.nanmean(a, axis=1)
        array([1.,  3.5]) # may vary

    nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>)
        Compute the median along the specified axis, while ignoring NaNs.

        Returns the median of the array elements.

        .. versionadded:: 1.9.0

        Parameters
        ----------
        a : array_like
            Input array or object that can be converted to an array.
        axis : {int, sequence of int, None}, optional
            Axis or axes along which the medians are computed. The default
            is to compute the median along a flattened version of the array.
            A sequence of axes is supported since version 1.9.0.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output,
            but the type (of the output) will be cast if necessary.
        overwrite_input : bool, optional
           If True, then allow use of memory of input array `a` for
           calculations. The input array will be modified by the call to
           `median`. This will save memory when you do not need to preserve
           the contents of the input array. Treat the input as undefined,
           but it will probably be fully or partially sorted. Default is
           False. If `overwrite_input` is ``True`` and `a` is not already an
           `ndarray`, an error will be raised.
        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 `a`.

            If this is anything but the default value it will be passed
            through (in the special case of an empty array) to the
            `mean` function of the underlying array.  If the array is
            a sub-class and `mean` does not have the kwarg `keepdims` this
            will raise a RuntimeError.

        Returns
        -------
        median : ndarray
            A new array holding the result. If the input contains integers
            or floats smaller than ``float64``, then the output data-type is
            ``np.float64``.  Otherwise, the data-type of the output is the
            same as that of the input. If `out` is specified, that array is
            returned instead.

        See Also
        --------
        mean, median, percentile

        Notes
        -----
        Given a vector ``V`` of length ``N``, the median of ``V`` is the
        middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
        ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two
        middle values of ``V_sorted`` when ``N`` is even.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
        >>> a[0, 1] = np.nan
        >>> a
        array([[10., nan,  4.],
               [ 3.,  2.,  1.]])
        >>> np.median(a)
        np.float64(nan)
        >>> np.nanmedian(a)
        3.0
        >>> np.nanmedian(a, axis=0)
        array([6.5, 2. , 2.5])
        >>> np.median(a, axis=1)
        array([nan,  2.])
        >>> b = a.copy()
        >>> np.nanmedian(b, axis=1, overwrite_input=True)
        array([7.,  2.])
        >>> assert not np.all(a==b)
        >>> b = a.copy()
        >>> np.nanmedian(b, axis=None, overwrite_input=True)
        3.0
        >>> assert not np.all(a==b)

    nanmin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return minimum of an array or minimum along an axis, ignoring any NaNs.
        When all-NaN slices are encountered a ``RuntimeWarning`` is raised and
        Nan is returned for that slice.

        Parameters
        ----------
        a : array_like
            Array containing numbers whose minimum is desired. If `a` is not an
            array, a conversion is attempted.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the minimum is computed. The default is to compute
            the minimum of the flattened array.
        out : ndarray, optional
            Alternate output array in which to place the result.  The default
            is ``None``; if provided, it must have the same shape as the
            expected output, but the type will be cast if necessary. See
            :ref:`ufuncs-output-type` for more details.

            .. versionadded:: 1.8.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 `a`.

            If the value is anything but the default, then
            `keepdims` will be passed through to the `min` method
            of sub-classes of `ndarray`.  If the sub-classes methods
            does not implement `keepdims` any exceptions will be raised.

            .. versionadded:: 1.8.0
        initial : scalar, optional
            The maximum value of an output element. Must be present to allow
            computation on empty slice. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.22.0
        where : array_like of bool, optional
            Elements to compare for the minimum. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.22.0

        Returns
        -------
        nanmin : ndarray
            An array with the same shape as `a`, with the specified axis
            removed.  If `a` is a 0-d array, or if axis is None, an ndarray
            scalar is returned.  The same dtype as `a` is returned.

        See Also
        --------
        nanmax :
            The maximum value of an array along a given axis, ignoring any NaNs.
        amin :
            The minimum value of an array along a given axis, propagating any NaNs.
        fmin :
            Element-wise minimum of two arrays, ignoring any NaNs.
        minimum :
            Element-wise minimum of two arrays, propagating any NaNs.
        isnan :
            Shows which elements are Not a Number (NaN).
        isfinite:
            Shows which elements are neither NaN nor infinity.

        amax, fmax, maximum

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754). This means that Not a Number is not equivalent to infinity.
        Positive infinity is treated as a very large number and negative
        infinity is treated as a very small (i.e. negative) number.

        If the input has a integer type the function is equivalent to np.min.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, np.nan]])
        >>> np.nanmin(a)
        1.0
        >>> np.nanmin(a, axis=0)
        array([1.,  2.])
        >>> np.nanmin(a, axis=1)
        array([1.,  3.])

        When positive infinity and negative infinity are present:

        >>> np.nanmin([1, 2, np.nan, np.inf])
        1.0
        >>> np.nanmin([1, 2, np.nan, -np.inf])
        -inf

    nanpercentile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=<no value>, *, weights=None, interpolation=None)
        Compute the qth percentile of the data along the specified axis,
        while ignoring nan values.

        Returns the qth percentile(s) of the array elements.

        .. versionadded:: 1.9.0

        Parameters
        ----------
        a : array_like
            Input array or object that can be converted to an array, containing
            nan values to be ignored.
        q : array_like of float
            Percentile or sequence of percentiles to compute, which must be
            between 0 and 100 inclusive.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the percentiles are computed. The default
            is to compute the percentile(s) along a flattened version of the
            array.
        out : ndarray, optional
            Alternative output array in which to place the result. It must have
            the same shape and buffer length as the expected output, but the
            type (of the output) will be cast if necessary.
        overwrite_input : bool, optional
            If True, then allow the input array `a` to be modified by
            intermediate calculations, to save memory. In this case, the
            contents of the input `a` after this function completes is
            undefined.
        method : str, optional
            This parameter specifies the method to use for estimating the
            percentile.  There are many different methods, some unique to NumPy.
            See the notes for explanation.  The options sorted by their R type
            as summarized in the H&F paper [1]_ are:

            1. 'inverted_cdf'
            2. 'averaged_inverted_cdf'
            3. 'closest_observation'
            4. 'interpolated_inverted_cdf'
            5. 'hazen'
            6. 'weibull'
            7. 'linear'  (default)
            8. 'median_unbiased'
            9. 'normal_unbiased'

            The first three methods are discontinuous.  NumPy further defines the
            following discontinuous variations of the default 'linear' (7.) option:

            * 'lower'
            * 'higher',
            * 'midpoint'
            * 'nearest'

            .. versionchanged:: 1.22.0
                This argument was previously called "interpolation" and only
                offered the "linear" default and last four options.

        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 `a`.

            If this is anything but the default value it will be passed
            through (in the special case of an empty array) to the
            `mean` function of the underlying array.  If the array is
            a sub-class and `mean` does not have the kwarg `keepdims` this
            will raise a RuntimeError.

        weights : array_like, optional
            An array of weights associated with the values in `a`. Each value in
            `a` contributes to the percentile according to its associated weight.
            The weights array can either be 1-D (in which case its length must be
            the size of `a` along the given axis) or of the same shape as `a`.
            If `weights=None`, then all data in `a` are assumed to have a
            weight equal to one.
            Only `method="inverted_cdf"` supports weights.

            .. versionadded:: 2.0.0

        interpolation : str, optional
            Deprecated name for the method keyword argument.

            .. deprecated:: 1.22.0

        Returns
        -------
        percentile : scalar or ndarray
            If `q` is a single percentile and `axis=None`, then the result
            is a scalar. If multiple percentiles are given, first axis of
            the result corresponds to the percentiles. The other axes are
            the axes that remain after the reduction of `a`. If the input
            contains integers or floats smaller than ``float64``, the output
            data-type is ``float64``. Otherwise, the output data-type is the
            same as that of the input. If `out` is specified, that array is
            returned instead.

        See Also
        --------
        nanmean
        nanmedian : equivalent to ``nanpercentile(..., 50)``
        percentile, median, mean
        nanquantile : equivalent to nanpercentile, except q in range [0, 1].

        Notes
        -----
        The behavior of `numpy.nanpercentile` with percentage `q` is that of
        `numpy.quantile` with argument ``q/100`` (ignoring nan values).
        For more information, please see `numpy.quantile`.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
        >>> a[0][1] = np.nan
        >>> a
        array([[10.,  nan,   4.],
              [ 3.,   2.,   1.]])
        >>> np.percentile(a, 50)
        np.float64(nan)
        >>> np.nanpercentile(a, 50)
        3.0
        >>> np.nanpercentile(a, 50, axis=0)
        array([6.5, 2. , 2.5])
        >>> np.nanpercentile(a, 50, axis=1, keepdims=True)
        array([[7.],
               [2.]])
        >>> m = np.nanpercentile(a, 50, axis=0)
        >>> out = np.zeros_like(m)
        >>> np.nanpercentile(a, 50, axis=0, out=out)
        array([6.5, 2. , 2.5])
        >>> m
        array([6.5,  2. ,  2.5])

        >>> b = a.copy()
        >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
        array([7., 2.])
        >>> assert not np.all(a==b)

        References
        ----------
        .. [1] R. J. Hyndman and Y. Fan,
           "Sample quantiles in statistical packages,"
           The American Statistician, 50(4), pp. 361-365, 1996

    nanprod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the product of array elements over a given axis treating Not a
        Numbers (NaNs) as ones.

        One is returned for slices that are all-NaN or empty.

        .. versionadded:: 1.10.0

        Parameters
        ----------
        a : array_like
            Array containing numbers whose product is desired. If `a` is not an
            array, a conversion is attempted.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the product is computed. The default is to compute
            the product of the flattened array.
        dtype : data-type, optional
            The type of the returned array and of the accumulator in which the
            elements are summed.  By default, the dtype of `a` is used.  An
            exception is when `a` has an integer type with less precision than
            the platform (u)intp. In that case, the default will be either
            (u)int32 or (u)int64 depending on whether the platform is 32 or 64
            bits. For inexact inputs, dtype must be inexact.
        out : ndarray, optional
            Alternate output array in which to place the result.  The default
            is ``None``. If provided, it must have the same shape as the
            expected output, but the type will be cast if necessary. See
            :ref:`ufuncs-output-type` for more details. The casting of NaN to integer
            can yield unexpected results.
        keepdims : bool, optional
            If 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 `arr`.
        initial : scalar, optional
            The starting value for this product. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.22.0
        where : array_like of bool, optional
            Elements to include in the product. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.22.0

        Returns
        -------
        nanprod : ndarray
            A new array holding the result is returned unless `out` is
            specified, in which case it is returned.

        See Also
        --------
        numpy.prod : Product across array propagating NaNs.
        isnan : Show which elements are NaN.

        Examples
        --------
        >>> import numpy as np
        >>> np.nanprod(1)
        1
        >>> np.nanprod([1])
        1
        >>> np.nanprod([1, np.nan])
        1.0
        >>> a = np.array([[1, 2], [3, np.nan]])
        >>> np.nanprod(a)
        6.0
        >>> np.nanprod(a, axis=0)
        array([3., 2.])

    nanquantile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=<no value>, *, weights=None, interpolation=None)
        Compute the qth quantile of the data along the specified axis,
        while ignoring nan values.
        Returns the qth quantile(s) of the array elements.

        .. versionadded:: 1.15.0

        Parameters
        ----------
        a : array_like
            Input array or object that can be converted to an array, containing
            nan values to be ignored
        q : array_like of float
            Probability or sequence of probabilities for the quantiles to compute.
            Values must be between 0 and 1 inclusive.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the quantiles are computed. The
            default is to compute the quantile(s) along a flattened
            version of the array.
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output,
            but the type (of the output) will be cast if necessary.
        overwrite_input : bool, optional
            If True, then allow the input array `a` to be modified by intermediate
            calculations, to save memory. In this case, the contents of the input
            `a` after this function completes is undefined.
        method : str, optional
            This parameter specifies the method to use for estimating the
            quantile.  There are many different methods, some unique to NumPy.
            See the notes for explanation.  The options sorted by their R type
            as summarized in the H&F paper [1]_ are:

            1. 'inverted_cdf'
            2. 'averaged_inverted_cdf'
            3. 'closest_observation'
            4. 'interpolated_inverted_cdf'
            5. 'hazen'
            6. 'weibull'
            7. 'linear'  (default)
            8. 'median_unbiased'
            9. 'normal_unbiased'

            The first three methods are discontinuous.  NumPy further defines the
            following discontinuous variations of the default 'linear' (7.) option:

            * 'lower'
            * 'higher',
            * 'midpoint'
            * 'nearest'

            .. versionchanged:: 1.22.0
                This argument was previously called "interpolation" and only
                offered the "linear" default and last four options.

        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 `a`.

            If this is anything but the default value it will be passed
            through (in the special case of an empty array) to the
            `mean` function of the underlying array.  If the array is
            a sub-class and `mean` does not have the kwarg `keepdims` this
            will raise a RuntimeError.

        weights : array_like, optional
            An array of weights associated with the values in `a`. Each value in
            `a` contributes to the quantile according to its associated weight.
            The weights array can either be 1-D (in which case its length must be
            the size of `a` along the given axis) or of the same shape as `a`.
            If `weights=None`, then all data in `a` are assumed to have a
            weight equal to one.
            Only `method="inverted_cdf"` supports weights.

            .. versionadded:: 2.0.0

        interpolation : str, optional
            Deprecated name for the method keyword argument.

            .. deprecated:: 1.22.0

        Returns
        -------
        quantile : scalar or ndarray
            If `q` is a single probability and `axis=None`, then the result
            is a scalar. If multiple probability levels are given, first axis of
            the result corresponds to the quantiles. The other axes are
            the axes that remain after the reduction of `a`. If the input
            contains integers or floats smaller than ``float64``, the output
            data-type is ``float64``. Otherwise, the output data-type is the
            same as that of the input. If `out` is specified, that array is
            returned instead.

        See Also
        --------
        quantile
        nanmean, nanmedian
        nanmedian : equivalent to ``nanquantile(..., 0.5)``
        nanpercentile : same as nanquantile, but with q in the range [0, 100].

        Notes
        -----
        The behavior of `numpy.nanquantile` is the same as that of
        `numpy.quantile` (ignoring nan values).
        For more information, please see `numpy.quantile`.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
        >>> a[0][1] = np.nan
        >>> a
        array([[10.,  nan,   4.],
              [ 3.,   2.,   1.]])
        >>> np.quantile(a, 0.5)
        np.float64(nan)
        >>> np.nanquantile(a, 0.5)
        3.0
        >>> np.nanquantile(a, 0.5, axis=0)
        array([6.5, 2. , 2.5])
        >>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
        array([[7.],
               [2.]])
        >>> m = np.nanquantile(a, 0.5, axis=0)
        >>> out = np.zeros_like(m)
        >>> np.nanquantile(a, 0.5, axis=0, out=out)
        array([6.5, 2. , 2.5])
        >>> m
        array([6.5,  2. ,  2.5])
        >>> b = a.copy()
        >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
        array([7., 2.])
        >>> assert not np.all(a==b)

        References
        ----------
        .. [1] R. J. Hyndman and Y. Fan,
           "Sample quantiles in statistical packages,"
           The American Statistician, 50(4), pp. 361-365, 1996

    nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>, mean=<no value>, correction=<no value>)
        Compute the standard deviation along the specified axis, while
        ignoring NaNs.

        Returns the standard deviation, a measure of the spread of a
        distribution, of the non-NaN array elements. The standard deviation is
        computed for the flattened array by default, otherwise over the
        specified axis.

        For all-NaN slices or slices with zero degrees of freedom, NaN is
        returned and a `RuntimeWarning` is raised.

        .. versionadded:: 1.8.0

        Parameters
        ----------
        a : array_like
            Calculate the standard deviation of the non-NaN values.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the standard deviation is computed. The default is
            to compute the standard deviation of the flattened array.
        dtype : dtype, optional
            Type to use in computing the standard deviation. For arrays of
            integer type the default is float64, for arrays of float types it
            is the same as the array type.
        out : ndarray, optional
            Alternative output array in which to place the result. It must have
            the same shape as the expected output but the type (of the
            calculated values) will be cast if necessary.
        ddof : {int, float}, optional
            Means Delta Degrees of Freedom.  The divisor used in calculations
            is ``N - ddof``, where ``N`` represents the number of non-NaN
            elements.  By default `ddof` is zero.

        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 `a`.

            If this value is anything but the default it is passed through
            as-is to the relevant functions of the sub-classes.  If these
            functions do not have a `keepdims` kwarg, a RuntimeError will
            be raised.
        where : array_like of bool, optional
            Elements to include in the standard deviation.
            See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.22.0

        mean : array_like, optional
            Provide the mean to prevent its recalculation. The mean should have
            a shape as if it was calculated with ``keepdims=True``.
            The axis for the calculation of the mean should be the same as used in
            the call to this std function.

            .. versionadded:: 1.26.0

        correction : {int, float}, optional
            Array API compatible name for the ``ddof`` parameter. Only one of them
            can be provided at the same time.

            .. versionadded:: 2.0.0

        Returns
        -------
        standard_deviation : ndarray, see dtype parameter above.
            If `out` is None, return a new array containing the standard
            deviation, otherwise return a reference to the output array. If
            ddof is >= the number of non-NaN elements in a slice or the slice
            contains only NaNs, then the result for that slice is NaN.

        See Also
        --------
        var, mean, std
        nanvar, nanmean
        :ref:`ufuncs-output-type`

        Notes
        -----
        The standard deviation is the square root of the average of the squared
        deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.

        The average squared deviation is normally calculated as
        ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is
        specified, the divisor ``N - ddof`` is used instead. In standard
        statistical practice, ``ddof=1`` provides an unbiased estimator of the
        variance of the infinite population. ``ddof=0`` provides a maximum
        likelihood estimate of the variance for normally distributed variables.
        The standard deviation computed in this function is the square root of
        the estimated variance, so even with ``ddof=1``, it will not be an
        unbiased estimate of the standard deviation per se.

        Note that, for complex numbers, `std` takes the absolute value before
        squaring, so that the result is always real and nonnegative.

        For floating-point input, the *std* is computed using the same
        precision the input has. Depending on the input data, this can cause
        the results to be inaccurate, especially for float32 (see example
        below).  Specifying a higher-accuracy accumulator using the `dtype`
        keyword can alleviate this issue.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, np.nan], [3, 4]])
        >>> np.nanstd(a)
        1.247219128924647
        >>> np.nanstd(a, axis=0)
        array([1., 0.])
        >>> np.nanstd(a, axis=1)
        array([0.,  0.5]) # may vary

    nansum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the sum of array elements over a given axis treating Not a
        Numbers (NaNs) as zero.

        In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
        empty. In later versions zero is returned.

        Parameters
        ----------
        a : array_like
            Array containing numbers whose sum is desired. If `a` is not an
            array, a conversion is attempted.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the sum is computed. The default is to compute the
            sum of the flattened array.
        dtype : data-type, optional
            The type of the returned array and of the accumulator in which the
            elements are summed.  By default, the dtype of `a` is used.  An
            exception is when `a` has an integer type with less precision than
            the platform (u)intp. In that case, the default will be either
            (u)int32 or (u)int64 depending on whether the platform is 32 or 64
            bits. For inexact inputs, dtype must be inexact.

            .. versionadded:: 1.8.0
        out : ndarray, optional
            Alternate output array in which to place the result.  The default
            is ``None``. If provided, it must have the same shape as the
            expected output, but the type will be cast if necessary.  See
            :ref:`ufuncs-output-type` for more details. The casting of NaN to integer
            can yield unexpected results.

            .. versionadded:: 1.8.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 `a`.


            If the value is anything but the default, then
            `keepdims` will be passed through to the `mean` or `sum` methods
            of sub-classes of `ndarray`.  If the sub-classes methods
            does not implement `keepdims` any exceptions will be raised.

            .. versionadded:: 1.8.0
        initial : scalar, optional
            Starting value for the sum. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.22.0
        where : array_like of bool, optional
            Elements to include in the sum. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.22.0

        Returns
        -------
        nansum : ndarray.
            A new array holding the result is returned unless `out` is
            specified, in which it is returned. The result has the same
            size as `a`, and the same shape as `a` if `axis` is not None
            or `a` is a 1-d array.

        See Also
        --------
        numpy.sum : Sum across array propagating NaNs.
        isnan : Show which elements are NaN.
        isfinite : Show which elements are not NaN or +/-inf.

        Notes
        -----
        If both positive and negative infinity are present, the sum will be Not
        A Number (NaN).

        Examples
        --------
        >>> import numpy as np
        >>> np.nansum(1)
        1
        >>> np.nansum([1])
        1
        >>> np.nansum([1, np.nan])
        1.0
        >>> a = np.array([[1, 1], [1, np.nan]])
        >>> np.nansum(a)
        3.0
        >>> np.nansum(a, axis=0)
        array([2.,  1.])
        >>> np.nansum([1, np.nan, np.inf])
        inf
        >>> np.nansum([1, np.nan, -np.inf])
        -inf
        >>> from numpy.testing import suppress_warnings
        >>> with np.errstate(invalid="ignore"):
        ...     np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
        np.float64(nan)

    nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>, mean=<no value>, correction=<no value>)
        Compute the variance along the specified axis, while ignoring NaNs.

        Returns the variance of the array elements, a measure of the spread of
        a distribution.  The variance is computed for the flattened array by
        default, otherwise over the specified axis.

        For all-NaN slices or slices with zero degrees of freedom, NaN is
        returned and a `RuntimeWarning` is raised.

        .. versionadded:: 1.8.0

        Parameters
        ----------
        a : array_like
            Array containing numbers whose variance is desired.  If `a` is not an
            array, a conversion is attempted.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the variance is computed.  The default is to compute
            the variance of the flattened array.
        dtype : data-type, optional
            Type to use in computing the variance.  For arrays of integer type
            the default is `float64`; for arrays of float types it is the same as
            the array type.
        out : ndarray, optional
            Alternate output array in which to place the result.  It must have
            the same shape as the expected output, but the type is cast if
            necessary.
        ddof : {int, float}, optional
            "Delta Degrees of Freedom": the divisor used in the calculation is
            ``N - ddof``, where ``N`` represents the number of non-NaN
            elements. By default `ddof` is zero.
        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 `a`.
        where : array_like of bool, optional
            Elements to include in the variance. See `~numpy.ufunc.reduce` for
            details.

            .. versionadded:: 1.22.0

        mean : array_like, optional
            Provide the mean to prevent its recalculation. The mean should have
            a shape as if it was calculated with ``keepdims=True``.
            The axis for the calculation of the mean should be the same as used in
            the call to this var function.

            .. versionadded:: 1.26.0

        correction : {int, float}, optional
            Array API compatible name for the ``ddof`` parameter. Only one of them
            can be provided at the same time.

            .. versionadded:: 2.0.0

        Returns
        -------
        variance : ndarray, see dtype parameter above
            If `out` is None, return a new array containing the variance,
            otherwise return a reference to the output array. If ddof is >= the
            number of non-NaN elements in a slice or the slice contains only
            NaNs, then the result for that slice is NaN.

        See Also
        --------
        std : Standard deviation
        mean : Average
        var : Variance while not ignoring NaNs
        nanstd, nanmean
        :ref:`ufuncs-output-type`

        Notes
        -----
        The variance is the average of the squared deviations from the mean,
        i.e.,  ``var = mean(abs(x - x.mean())**2)``.

        The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
        If, however, `ddof` is specified, the divisor ``N - ddof`` is used
        instead.  In standard statistical practice, ``ddof=1`` provides an
        unbiased estimator of the variance of a hypothetical infinite
        population.  ``ddof=0`` provides a maximum likelihood estimate of the
        variance for normally distributed variables.

        Note that for complex numbers, the absolute value is taken before
        squaring, so that the result is always real and nonnegative.

        For floating-point input, the variance is computed using the same
        precision the input has.  Depending on the input data, this can cause
        the results to be inaccurate, especially for `float32` (see example
        below).  Specifying a higher-accuracy accumulator using the ``dtype``
        keyword can alleviate this issue.

        For this function to work on sub-classes of ndarray, they must define
        `sum` with the kwarg `keepdims`

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, np.nan], [3, 4]])
        >>> np.nanvar(a)
        1.5555555555555554
        >>> np.nanvar(a, axis=0)
        array([1.,  0.])
        >>> np.nanvar(a, axis=1)
        array([0.,  0.25])  # may vary

    ndim(a)
        Return the number of dimensions of an array.

        Parameters
        ----------
        a : array_like
            Input array.  If it is not already an ndarray, a conversion is
            attempted.

        Returns
        -------
        number_of_dimensions : int
            The number of dimensions in `a`.  Scalars are zero-dimensional.

        See Also
        --------
        ndarray.ndim : equivalent method
        shape : dimensions of array
        ndarray.shape : dimensions of array

        Examples
        --------
        >>> import numpy as np
        >>> np.ndim([[1,2,3],[4,5,6]])
        2
        >>> np.ndim(np.array([[1,2,3],[4,5,6]]))
        2
        >>> np.ndim(1)
        0

    nested_iters(...)
        nested_iters(op, axes, flags=None, op_flags=None, op_dtypes=None,     order="K", casting="safe", buffersize=0)

        Create nditers for use in nested loops

        Create a tuple of `nditer` objects which iterate in nested loops over
        different axes of the op argument. The first iterator is used in the
        outermost loop, the last in the innermost loop. Advancing one will change
        the subsequent iterators to point at its new element.

        Parameters
        ----------
        op : ndarray or sequence of array_like
            The array(s) to iterate over.

        axes : list of list of int
            Each item is used as an "op_axes" argument to an nditer

        flags, op_flags, op_dtypes, order, casting, buffersize (optional)
            See `nditer` parameters of the same name

        Returns
        -------
        iters : tuple of nditer
            An nditer for each item in `axes`, outermost first

        See Also
        --------
        nditer

        Examples
        --------

        Basic usage. Note how y is the "flattened" version of
        [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified
        the first iter's axes as [1]

        >>> import numpy as np
        >>> a = np.arange(12).reshape(2, 3, 2)
        >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=["multi_index"])
        >>> for x in i:
        ...      print(i.multi_index)
        ...      for y in j:
        ...          print('', j.multi_index, y)
        (0,)
         (0, 0) 0
         (0, 1) 1
         (1, 0) 6
         (1, 1) 7
        (1,)
         (0, 0) 2
         (0, 1) 3
         (1, 0) 8
         (1, 1) 9
        (2,)
         (0, 0) 4
         (0, 1) 5
         (1, 0) 10
         (1, 1) 11

    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.

        To group the indices by element, rather than dimension, use `argwhere`,
        which returns a row for each non-zero element.

        .. note::

           When called on a zero-d array or scalar, ``nonzero(a)`` is treated
           as ``nonzero(atleast_1d(a))``.

           .. deprecated:: 1.17.0

              Use `atleast_1d` explicitly if this behavior is deliberate.

        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.

        Notes
        -----
        While the nonzero values can be obtained with ``a[nonzero(a)]``, it is
        recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which
        will correctly handle 0-d arrays.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
        >>> x
        array([[3, 0, 0],
               [0, 4, 0],
               [5, 6, 0]])
        >>> np.nonzero(x)
        (array([0, 1, 2, 2]), array([0, 1, 0, 1]))

        >>> x[np.nonzero(x)]
        array([3, 4, 5, 6])
        >>> 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]))

        Using this result to index `a` is equivalent to using the mask directly:

        >>> a[np.nonzero(a > 3)]
        array([4, 5, 6, 7, 8, 9])
        >>> a[a > 3]  # prefer this spelling
        array([4, 5, 6, 7, 8, 9])

        ``nonzero`` can also be called as a method of the array.

        >>> (a > 3).nonzero()
        (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

    ones(shape, dtype=None, order='C', *, device=None, like=None)
        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, default: C
            Whether to store multi-dimensional data in row-major
            (C-style) or column-major (Fortran-style) order in
            memory.
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Array of ones with the given shape, dtype, and order.

        See Also
        --------
        ones_like : Return an array of ones with shape and type of input.
        empty : Return a new uninitialized array.
        zeros : Return a new array setting values to zero.
        full : Return a new array of given shape filled with value.

        Examples
        --------
        >>> import numpy as np
        >>> 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.]])

    ones_like(a, dtype=None, order='K', subok=True, shape=None, *, device=None)
        Return an array of ones 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.
        shape : int or sequence of ints, optional.
            Overrides the shape of the result. If order='K' and the number of
            dimensions is unchanged, will try to keep order, otherwise,
            order='C' is implied.

            .. versionadded:: 1.17.0
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0

        Returns
        -------
        out : ndarray
            Array of ones with the same shape and type as `a`.

        See Also
        --------
        empty_like : Return an empty array with shape and type of input.
        zeros_like : Return an array of zeros with shape and type of input.
        full_like : Return a new array with shape of input filled with value.
        ones : Return a new array setting values to one.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(6)
        >>> x = x.reshape((2, 3))
        >>> x
        array([[0, 1, 2],
               [3, 4, 5]])
        >>> np.ones_like(x)
        array([[1, 1, 1],
               [1, 1, 1]])

        >>> y = np.arange(3, dtype=float)
        >>> y
        array([0., 1., 2.])
        >>> np.ones_like(y)
        array([1.,  1.,  1.])

    outer(a, b, out=None)
        Compute the outer product of two vectors.

        Given two vectors `a` and `b` of length ``M`` and ``N``, respectively,
        the outer product [1]_ is::

          [[a_0*b_0  a_0*b_1 ... a_0*b_{N-1} ]
           [a_1*b_0    .
           [ ...          .
           [a_{M-1}*b_0            a_{M-1}*b_{N-1} ]]

        Parameters
        ----------
        a : (M,) array_like
            First input vector.  Input is flattened if
            not already 1-dimensional.
        b : (N,) array_like
            Second input vector.  Input is flattened if
            not already 1-dimensional.
        out : (M, N) ndarray, optional
            A location where the result is stored

            .. versionadded:: 1.9.0

        Returns
        -------
        out : (M, N) ndarray
            ``out[i, j] = a[i] * b[j]``

        See also
        --------
        inner
        einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
        ufunc.outer : A generalization to dimensions other than 1D and other
                      operations. ``np.multiply.outer(a.ravel(), b.ravel())``
                      is the equivalent.
        linalg.outer : An Array API compatible variation of ``np.outer``,
                       which accepts 1-dimensional inputs only.
        tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))``
                    is the equivalent.

        References
        ----------
        .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
               ed., Baltimore, MD, Johns Hopkins University Press, 1996,
               pg. 8.

        Examples
        --------
        Make a (*very* coarse) grid for computing a Mandelbrot set:

        >>> import numpy as np
        >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
        >>> rl
        array([[-2., -1.,  0.,  1.,  2.],
               [-2., -1.,  0.,  1.,  2.],
               [-2., -1.,  0.,  1.,  2.],
               [-2., -1.,  0.,  1.,  2.],
               [-2., -1.,  0.,  1.,  2.]])
        >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
        >>> im
        array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
               [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
               [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
               [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
               [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
        >>> grid = rl + im
        >>> grid
        array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
               [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
               [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
               [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
               [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])

        An example using a "vector" of letters:

        >>> x = np.array(['a', 'b', 'c'], dtype=object)
        >>> np.outer(x, [1, 2, 3])
        array([['a', 'aa', 'aaa'],
               ['b', 'bb', 'bbb'],
               ['c', 'cc', 'ccc']], dtype=object)

    packbits(...)
        packbits(a, /, axis=None, bitorder='big')

        Packs the elements of a binary-valued array into bits in a uint8 array.

        The result is padded to full bytes by inserting zero bits at the end.

        Parameters
        ----------
        a : array_like
            An array of integers or booleans whose elements should be packed to
            bits.
        axis : int, optional
            The dimension over which bit-packing is done.
            ``None`` implies packing the flattened array.
        bitorder : {'big', 'little'}, optional
            The order of the input bits. 'big' will mimic bin(val),
            ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will
            reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.
            Defaults to 'big'.

            .. versionadded:: 1.17.0

        Returns
        -------
        packed : ndarray
            Array of type uint8 whose elements represent bits corresponding to the
            logical (0 or nonzero) value of the input elements. The shape of
            `packed` has the same number of dimensions as the input (unless `axis`
            is None, in which case the output is 1-D).

        See Also
        --------
        unpackbits: Unpacks elements of a uint8 array into a binary-valued output
                    array.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[[1,0,1],
        ...                [0,1,0]],
        ...               [[1,1,0],
        ...                [0,0,1]]])
        >>> b = np.packbits(a, axis=-1)
        >>> b
        array([[[160],
                [ 64]],
               [[192],
                [ 32]]], dtype=uint8)

        Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,
        and 32 = 0010 0000.

    pad(array, pad_width, mode='constant', **kwargs)
        Pad an array.

        Parameters
        ----------
        array : array_like of rank N
            The array to pad.
        pad_width : {sequence, array_like, int}
            Number of values padded to the edges of each axis.
            ``((before_1, after_1), ... (before_N, after_N))`` unique pad widths
            for each axis.
            ``(before, after)`` or ``((before, after),)`` yields same before
            and after pad for each axis.
            ``(pad,)`` or ``int`` is a shortcut for before = after = pad width
            for all axes.
        mode : str or function, optional
            One of the following string values or a user supplied function.

            'constant' (default)
                Pads with a constant value.
            'edge'
                Pads with the edge values of array.
            'linear_ramp'
                Pads with the linear ramp between end_value and the
                array edge value.
            'maximum'
                Pads with the maximum value of all or part of the
                vector along each axis.
            'mean'
                Pads with the mean value of all or part of the
                vector along each axis.
            'median'
                Pads with the median value of all or part of the
                vector along each axis.
            'minimum'
                Pads with the minimum value of all or part of the
                vector along each axis.
            'reflect'
                Pads with the reflection of the vector mirrored on
                the first and last values of the vector along each
                axis.
            'symmetric'
                Pads with the reflection of the vector mirrored
                along the edge of the array.
            'wrap'
                Pads with the wrap of the vector along the axis.
                The first values are used to pad the end and the
                end values are used to pad the beginning.
            'empty'
                Pads with undefined values.

                .. versionadded:: 1.17

            <function>
                Padding function, see Notes.
        stat_length : sequence or int, optional
            Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
            values at edge of each axis used to calculate the statistic value.

            ``((before_1, after_1), ... (before_N, after_N))`` unique statistic
            lengths for each axis.

            ``(before, after)`` or ``((before, after),)`` yields same before
            and after statistic lengths for each axis.

            ``(stat_length,)`` or ``int`` is a shortcut for
            ``before = after = statistic`` length for all axes.

            Default is ``None``, to use the entire axis.
        constant_values : sequence or scalar, optional
            Used in 'constant'.  The values to set the padded values for each
            axis.

            ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
            for each axis.

            ``(before, after)`` or ``((before, after),)`` yields same before
            and after constants for each axis.

            ``(constant,)`` or ``constant`` is a shortcut for
            ``before = after = constant`` for all axes.

            Default is 0.
        end_values : sequence or scalar, optional
            Used in 'linear_ramp'.  The values used for the ending value of the
            linear_ramp and that will form the edge of the padded array.

            ``((before_1, after_1), ... (before_N, after_N))`` unique end values
            for each axis.

            ``(before, after)`` or ``((before, after),)`` yields same before
            and after end values for each axis.

            ``(constant,)`` or ``constant`` is a shortcut for
            ``before = after = constant`` for all axes.

            Default is 0.
        reflect_type : {'even', 'odd'}, optional
            Used in 'reflect', and 'symmetric'.  The 'even' style is the
            default with an unaltered reflection around the edge value.  For
            the 'odd' style, the extended part of the array is created by
            subtracting the reflected values from two times the edge value.

        Returns
        -------
        pad : ndarray
            Padded array of rank equal to `array` with shape increased
            according to `pad_width`.

        Notes
        -----
        .. versionadded:: 1.7.0

        For an array with rank greater than 1, some of the padding of later
        axes is calculated from padding of previous axes.  This is easiest to
        think about with a rank 2 array where the corners of the padded array
        are calculated by using padded values from the first axis.

        The padding function, if used, should modify a rank 1 array in-place. It
        has the following signature::

            padding_func(vector, iaxis_pad_width, iaxis, kwargs)

        where

        vector : ndarray
            A rank 1 array already padded with zeros.  Padded values are
            vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
        iaxis_pad_width : tuple
            A 2-tuple of ints, iaxis_pad_width[0] represents the number of
            values padded at the beginning of vector where
            iaxis_pad_width[1] represents the number of values padded at
            the end of vector.
        iaxis : int
            The axis currently being calculated.
        kwargs : dict
            Any keyword arguments the function requires.

        Examples
        --------
        >>> import numpy as np
        >>> a = [1, 2, 3, 4, 5]
        >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
        array([4, 4, 1, ..., 6, 6, 6])

        >>> np.pad(a, (2, 3), 'edge')
        array([1, 1, 1, ..., 5, 5, 5])

        >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
        array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])

        >>> np.pad(a, (2,), 'maximum')
        array([5, 5, 1, 2, 3, 4, 5, 5, 5])

        >>> np.pad(a, (2,), 'mean')
        array([3, 3, 1, 2, 3, 4, 5, 3, 3])

        >>> np.pad(a, (2,), 'median')
        array([3, 3, 1, 2, 3, 4, 5, 3, 3])

        >>> a = [[1, 2], [3, 4]]
        >>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
        array([[1, 1, 1, 2, 1, 1, 1],
               [1, 1, 1, 2, 1, 1, 1],
               [1, 1, 1, 2, 1, 1, 1],
               [1, 1, 1, 2, 1, 1, 1],
               [3, 3, 3, 4, 3, 3, 3],
               [1, 1, 1, 2, 1, 1, 1],
               [1, 1, 1, 2, 1, 1, 1]])

        >>> a = [1, 2, 3, 4, 5]
        >>> np.pad(a, (2, 3), 'reflect')
        array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])

        >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
        array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

        >>> np.pad(a, (2, 3), 'symmetric')
        array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])

        >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
        array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])

        >>> np.pad(a, (2, 3), 'wrap')
        array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])

        >>> def pad_with(vector, pad_width, iaxis, kwargs):
        ...     pad_value = kwargs.get('padder', 10)
        ...     vector[:pad_width[0]] = pad_value
        ...     vector[-pad_width[1]:] = pad_value
        >>> a = np.arange(6)
        >>> a = a.reshape((2, 3))
        >>> np.pad(a, 2, pad_with)
        array([[10, 10, 10, 10, 10, 10, 10],
               [10, 10, 10, 10, 10, 10, 10],
               [10, 10,  0,  1,  2, 10, 10],
               [10, 10,  3,  4,  5, 10, 10],
               [10, 10, 10, 10, 10, 10, 10],
               [10, 10, 10, 10, 10, 10, 10]])
        >>> np.pad(a, 2, pad_with, padder=100)
        array([[100, 100, 100, 100, 100, 100, 100],
               [100, 100, 100, 100, 100, 100, 100],
               [100, 100,   0,   1,   2, 100, 100],
               [100, 100,   3,   4,   5, 100, 100],
               [100, 100, 100, 100, 100, 100, 100],
               [100, 100, 100, 100, 100, 100, 100]])

    partition(a, kth, axis=-1, kind='introselect', order=None)
        Return a partitioned copy of an array.

        Creates a copy of the array and partially sorts it in such a way that
        the value of the element in k-th position is in the position it would be
        in a sorted array. In the output array, all elements smaller than the k-th
        element are located to the left of this element and all equal or greater
        are located to its right. The ordering of the elements in the two
        partitions on the either side of the k-th element in the output array is
        undefined.

        .. versionadded:: 1.8.0

        Parameters
        ----------
        a : array_like
            Array to be sorted.
        kth : int or sequence of ints
            Element index to partition by. The k-th value of the element
            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 of all elements in the partitions is undefined. If
            provided with a sequence of k-th it will partition all elements
            indexed by k-th  of them into their sorted position at once.

            .. deprecated:: 1.22.0
                Passing booleans as index is deprecated.
        axis : int or None, optional
            Axis along which to sort. If None, the array is flattened before
            sorting. The default is -1, which sorts 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.  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
        -------
        partitioned_array : ndarray
            Array of the same type and shape as `a`.

        See Also
        --------
        ndarray.partition : Method to sort an array in-place.
        argpartition : Indirect partition.
        sort : Full sorting

        Notes
        -----
        The various selection algorithms are characterized by their average
        speed, worst case performance, work space size, and whether they are
        stable. A stable sort keeps items with the same key in the same
        relative order. The available algorithms have the following
        properties:

        ================= ======= ============= ============ =======
           kind            speed   worst case    work space  stable
        ================= ======= ============= ============ =======
        'introselect'        1        O(n)           0         no
        ================= ======= ============= ============ =======

        All the partition algorithms make temporary copies of the data when
        partitioning along any but the last axis.  Consequently,
        partitioning along the last axis is faster and uses less space than
        partitioning along any other axis.

        The sort order for complex numbers is lexicographic. If both the
        real and imaginary parts are non-nan then the order is determined by
        the real parts except when they are equal, in which case the order
        is determined by the imaginary parts.

        The sort order of ``np.nan`` is bigger than ``np.inf``.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([7, 1, 7, 7, 1, 5, 7, 2, 3, 2, 6, 2, 3, 0])
        >>> p = np.partition(a, 4)
        >>> p
        array([0, 1, 2, 1, 2, 5, 2, 3, 3, 6, 7, 7, 7, 7]) # may vary

        ``p[4]`` is 2;  all elements in ``p[:4]`` are less than or equal
        to ``p[4]``, and all elements in ``p[5:]`` are greater than or
        equal to ``p[4]``.  The partition is::

            [0, 1, 2, 1], [2], [5, 2, 3, 3, 6, 7, 7, 7, 7]

        The next example shows the use of multiple values passed to `kth`.

        >>> p2 = np.partition(a, (4, 8))
        >>> p2
        array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7])

        ``p2[4]`` is 2  and ``p2[8]`` is 5.  All elements in ``p2[:4]``
        are less than or equal to ``p2[4]``, all elements in ``p2[5:8]``
        are greater than or equal to ``p2[4]`` and less than or equal to
        ``p2[8]``, and all elements in ``p2[9:]`` are greater than or
        equal to ``p2[8]``.  The partition is::

            [0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7]

    percentile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None, interpolation=None)
        Compute the q-th percentile of the data along the specified axis.

        Returns the q-th percentile(s) of the array elements.

        Parameters
        ----------
        a : array_like of real numbers
            Input array or object that can be converted to an array.
        q : array_like of float
            Percentage or sequence of percentages for the percentiles to compute.
            Values must be between 0 and 100 inclusive.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the percentiles are computed. The
            default is to compute the percentile(s) along a flattened
            version of the array.

            .. versionchanged:: 1.9.0
                A tuple of axes is supported
        out : ndarray, optional
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output,
            but the type (of the output) will be cast if necessary.
        overwrite_input : bool, optional
            If True, then allow the input array `a` to be modified by intermediate
            calculations, to save memory. In this case, the contents of the input
            `a` after this function completes is undefined.
        method : str, optional
            This parameter specifies the method to use for estimating the
            percentile.  There are many different methods, some unique to NumPy.
            See the notes for explanation.  The options sorted by their R type
            as summarized in the H&F paper [1]_ are:

            1. 'inverted_cdf'
            2. 'averaged_inverted_cdf'
            3. 'closest_observation'
            4. 'interpolated_inverted_cdf'
            5. 'hazen'
            6. 'weibull'
            7. 'linear'  (default)
            8. 'median_unbiased'
            9. 'normal_unbiased'

            The first three methods are discontinuous.  NumPy further defines the
            following discontinuous variations of the default 'linear' (7.) option:

            * 'lower'
            * 'higher',
            * 'midpoint'
            * 'nearest'

            .. versionchanged:: 1.22.0
                This argument was previously called "interpolation" and only
                offered the "linear" default and last four options.

        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 `a`.

            .. versionadded:: 1.9.0

         weights : array_like, optional
            An array of weights associated with the values in `a`. Each value in
            `a` contributes to the percentile according to its associated weight.
            The weights array can either be 1-D (in which case its length must be
            the size of `a` along the given axis) or of the same shape as `a`.
            If `weights=None`, then all data in `a` are assumed to have a
            weight equal to one.
            Only `method="inverted_cdf"` supports weights.
            See the notes for more details.

            .. versionadded:: 2.0.0

        interpolation : str, optional
            Deprecated name for the method keyword argument.

            .. deprecated:: 1.22.0

        Returns
        -------
        percentile : scalar or ndarray
            If `q` is a single percentile and `axis=None`, then the result
            is a scalar. If multiple percentiles are given, first axis of
            the result corresponds to the percentiles. The other axes are
            the axes that remain after the reduction of `a`. If the input
            contains integers or floats smaller than ``float64``, the output
            data-type is ``float64``. Otherwise, the output data-type is the
            same as that of the input. If `out` is specified, that array is
            returned instead.

        See Also
        --------
        mean
        median : equivalent to ``percentile(..., 50)``
        nanpercentile
        quantile : equivalent to percentile, except q in the range [0, 1].

        Notes
        -----
        The behavior of `numpy.percentile` with percentage `q` is
        that of `numpy.quantile` with argument ``q/100``.
        For more information, please see `numpy.quantile`.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[10, 7, 4], [3, 2, 1]])
        >>> a
        array([[10,  7,  4],
               [ 3,  2,  1]])
        >>> np.percentile(a, 50)
        3.5
        >>> np.percentile(a, 50, axis=0)
        array([6.5, 4.5, 2.5])
        >>> np.percentile(a, 50, axis=1)
        array([7.,  2.])
        >>> np.percentile(a, 50, axis=1, keepdims=True)
        array([[7.],
               [2.]])

        >>> m = np.percentile(a, 50, axis=0)
        >>> out = np.zeros_like(m)
        >>> np.percentile(a, 50, axis=0, out=out)
        array([6.5, 4.5, 2.5])
        >>> m
        array([6.5, 4.5, 2.5])

        >>> b = a.copy()
        >>> np.percentile(b, 50, axis=1, overwrite_input=True)
        array([7.,  2.])
        >>> assert not np.all(a == b)

        The different methods can be visualized graphically:

        .. plot::

            import matplotlib.pyplot as plt

            a = np.arange(4)
            p = np.linspace(0, 100, 6001)
            ax = plt.gca()
            lines = [
                ('linear', '-', 'C0'),
                ('inverted_cdf', ':', 'C1'),
                # Almost the same as `inverted_cdf`:
                ('averaged_inverted_cdf', '-.', 'C1'),
                ('closest_observation', ':', 'C2'),
                ('interpolated_inverted_cdf', '--', 'C1'),
                ('hazen', '--', 'C3'),
                ('weibull', '-.', 'C4'),
                ('median_unbiased', '--', 'C5'),
                ('normal_unbiased', '-.', 'C6'),
                ]
            for method, style, color in lines:
                ax.plot(
                    p, np.percentile(a, p, method=method),
                    label=method, linestyle=style, color=color)
            ax.set(
                title='Percentiles for different methods and data: ' + str(a),
                xlabel='Percentile',
                ylabel='Estimated percentile value',
                yticks=a)
            ax.legend(bbox_to_anchor=(1.03, 1))
            plt.tight_layout()
            plt.show()

        References
        ----------
        .. [1] R. J. Hyndman and Y. Fan,
           "Sample quantiles in statistical packages,"
           The American Statistician, 50(4), pp. 361-365, 1996

    permute_dims = transpose(a, axes=None)
        Returns an array with axes transposed.

        For a 1-D array, this returns an unchanged view of the original array, as a
        transposed vector is simply the same vector.
        To convert a 1-D array into a 2-D column vector, an additional dimension
        must be added, e.g., ``np.atleast_2d(a).T`` achieves this, as does
        ``a[:, np.newaxis]``.
        For a 2-D array, this is the standard 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, then
        ``transpose(a).shape == a.shape[::-1]``.

        Parameters
        ----------
        a : array_like
            Input array.
        axes : tuple or list of ints, optional
            If specified, it must be a tuple or list which contains a permutation
            of [0,1,...,N-1] where N is the number of axes of `a`. The `i`'th axis
            of the returned array will correspond to the axis numbered ``axes[i]``
            of the input. If not specified, defaults to ``range(a.ndim)[::-1]``,
            which reverses the order of the axes.

        Returns
        -------
        p : ndarray
            `a` with its axes permuted. A view is returned whenever possible.

        See Also
        --------
        ndarray.transpose : Equivalent method.
        moveaxis : Move axes of an array to new positions.
        argsort : Return the indices that would sort an array.

        Notes
        -----
        Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors
        when using the `axes` keyword argument.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> a
        array([[1, 2],
               [3, 4]])
        >>> np.transpose(a)
        array([[1, 3],
               [2, 4]])

        >>> a = np.array([1, 2, 3, 4])
        >>> a
        array([1, 2, 3, 4])
        >>> np.transpose(a)
        array([1, 2, 3, 4])

        >>> a = np.ones((1, 2, 3))
        >>> np.transpose(a, (1, 0, 2)).shape
        (2, 1, 3)

        >>> a = np.ones((2, 3, 4, 5))
        >>> np.transpose(a).shape
        (5, 4, 3, 2)

    piecewise(x, condlist, funclist, *args, **kw)
        Evaluate a piecewise-defined function.

        Given a set of conditions and corresponding functions, evaluate each
        function on the input data wherever its condition is true.

        Parameters
        ----------
        x : ndarray or scalar
            The input domain.
        condlist : list of bool arrays or bool scalars
            Each boolean array corresponds to a function in `funclist`.  Wherever
            `condlist[i]` is True, `funclist[i](x)` is used as the output value.

            Each boolean array in `condlist` selects a piece of `x`,
            and should therefore be of the same shape as `x`.

            The length of `condlist` must correspond to that of `funclist`.
            If one extra function is given, i.e. if
            ``len(funclist) == len(condlist) + 1``, then that extra function
            is the default value, used wherever all conditions are false.
        funclist : list of callables, f(x,*args,**kw), or scalars
            Each function is evaluated over `x` wherever its corresponding
            condition is True.  It should take a 1d array as input and give an 1d
            array or a scalar value as output.  If, instead of a callable,
            a scalar is provided then a constant function (``lambda x: scalar``) is
            assumed.
        args : tuple, optional
            Any further arguments given to `piecewise` are passed to the functions
            upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then
            each function is called as ``f(x, 1, 'a')``.
        kw : dict, optional
            Keyword arguments used in calling `piecewise` are passed to the
            functions upon execution, i.e., if called
            ``piecewise(..., ..., alpha=1)``, then each function is called as
            ``f(x, alpha=1)``.

        Returns
        -------
        out : ndarray
            The output is the same shape and type as x and is found by
            calling the functions in `funclist` on the appropriate portions of `x`,
            as defined by the boolean arrays in `condlist`.  Portions not covered
            by any condition have a default value of 0.


        See Also
        --------
        choose, select, where

        Notes
        -----
        This is similar to choose or select, except that functions are
        evaluated on elements of `x` that satisfy the corresponding condition from
        `condlist`.

        The result is::

                |--
                |funclist[0](x[condlist[0]])
          out = |funclist[1](x[condlist[1]])
                |...
                |funclist[n2](x[condlist[n2]])
                |--

        Examples
        --------
        >>> import numpy as np

        Define the signum function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.

        >>> x = np.linspace(-2.5, 2.5, 6)
        >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
        array([-1., -1., -1.,  1.,  1.,  1.])

        Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for
        ``x >= 0``.

        >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
        array([2.5,  1.5,  0.5,  0.5,  1.5,  2.5])

        Apply the same function to a scalar value.

        >>> y = -2
        >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
        array(2)

    place(arr, mask, vals)
        Change elements of an array based on conditional and input values.

        Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that
        `place` uses the first N elements of `vals`, where N is the number of
        True values in `mask`, while `copyto` uses the elements where `mask`
        is True.

        Note that `extract` does the exact opposite of `place`.

        Parameters
        ----------
        arr : ndarray
            Array to put data into.
        mask : array_like
            Boolean mask array. Must have the same size as `a`.
        vals : 1-D sequence
            Values to put into `a`. Only the first N elements are used, where
            N is the number of True values in `mask`. If `vals` is smaller
            than N, it will be repeated, and if elements of `a` are to be masked,
            this sequence must be non-empty.

        See Also
        --------
        copyto, put, take, extract

        Examples
        --------
        >>> import numpy as np
        >>> arr = np.arange(6).reshape(2, 3)
        >>> np.place(arr, arr>2, [44, 55])
        >>> arr
        array([[ 0,  1,  2],
               [44, 55, 44]])

    poly(seq_of_zeros)
        Find the coefficients of a polynomial with the given sequence of roots.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        Returns the coefficients of the polynomial whose leading coefficient
        is one for the given sequence of zeros (multiple roots must be included
        in the sequence as many times as their multiplicity; see Examples).
        A square matrix (or array, which will be treated as a matrix) can also
        be given, in which case the coefficients of the characteristic polynomial
        of the matrix are returned.

        Parameters
        ----------
        seq_of_zeros : array_like, shape (N,) or (N, N)
            A sequence of polynomial roots, or a square array or matrix object.

        Returns
        -------
        c : ndarray
            1D array of polynomial coefficients from highest to lowest degree:

            ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
            where c[0] always equals 1.

        Raises
        ------
        ValueError
            If input is the wrong shape (the input must be a 1-D or square
            2-D array).

        See Also
        --------
        polyval : Compute polynomial values.
        roots : Return the roots of a polynomial.
        polyfit : Least squares polynomial fit.
        poly1d : A one-dimensional polynomial class.

        Notes
        -----
        Specifying the roots of a polynomial still leaves one degree of
        freedom, typically represented by an undetermined leading
        coefficient. [1]_ In the case of this function, that coefficient -
        the first one in the returned array - is always taken as one. (If
        for some reason you have one other point, the only automatic way
        presently to leverage that information is to use ``polyfit``.)

        The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
        matrix **A** is given by

        :math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`,

        where **I** is the `n`-by-`n` identity matrix. [2]_

        References
        ----------
        .. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry,
           Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996.

        .. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition,"
           Academic Press, pg. 182, 1980.

        Examples
        --------
        Given a sequence of a polynomial's zeros:

        >>> import numpy as np

        >>> np.poly((0, 0, 0)) # Multiple root example
        array([1., 0., 0., 0.])

        The line above represents z**3 + 0*z**2 + 0*z + 0.

        >>> np.poly((-1./2, 0, 1./2))
        array([ 1.  ,  0.  , -0.25,  0.  ])

        The line above represents z**3 - z/4

        >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
        array([ 1.        , -0.77086955,  0.08618131,  0.        ]) # random

        Given a square array object:

        >>> P = np.array([[0, 1./3], [-1./2, 0]])
        >>> np.poly(P)
        array([1.        , 0.        , 0.16666667])

        Note how in all cases the leading coefficient is always 1.

    polyadd(a1, a2)
        Find the sum of two polynomials.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        Returns the polynomial resulting from the sum of two input polynomials.
        Each input must be either a poly1d object or a 1D sequence of polynomial
        coefficients, from highest to lowest degree.

        Parameters
        ----------
        a1, a2 : array_like or poly1d object
            Input polynomials.

        Returns
        -------
        out : ndarray or poly1d object
            The sum of the inputs. If either input is a poly1d object, then the
            output is also a poly1d object. Otherwise, it is a 1D array of
            polynomial coefficients from highest to lowest degree.

        See Also
        --------
        poly1d : A one-dimensional polynomial class.
        poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval

        Examples
        --------
        >>> import numpy as np
        >>> np.polyadd([1, 2], [9, 5, 4])
        array([9, 6, 6])

        Using poly1d objects:

        >>> p1 = np.poly1d([1, 2])
        >>> p2 = np.poly1d([9, 5, 4])
        >>> print(p1)
        1 x + 2
        >>> print(p2)
           2
        9 x + 5 x + 4
        >>> print(np.polyadd(p1, p2))
           2
        9 x + 6 x + 6

    polyder(p, m=1)
        Return the derivative of the specified order of a polynomial.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        Parameters
        ----------
        p : poly1d or sequence
            Polynomial to differentiate.
            A sequence is interpreted as polynomial coefficients, see `poly1d`.
        m : int, optional
            Order of differentiation (default: 1)

        Returns
        -------
        der : poly1d
            A new polynomial representing the derivative.

        See Also
        --------
        polyint : Anti-derivative of a polynomial.
        poly1d : Class for one-dimensional polynomials.

        Examples
        --------
        The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:

        >>> import numpy as np

        >>> p = np.poly1d([1,1,1,1])
        >>> p2 = np.polyder(p)
        >>> p2
        poly1d([3, 2, 1])

        which evaluates to:

        >>> p2(2.)
        17.0

        We can verify this, approximating the derivative with
        ``(f(x + h) - f(x))/h``:

        >>> (p(2. + 0.001) - p(2.)) / 0.001
        17.007000999997857

        The fourth-order derivative of a 3rd-order polynomial is zero:

        >>> np.polyder(p, 2)
        poly1d([6, 2])
        >>> np.polyder(p, 3)
        poly1d([6])
        >>> np.polyder(p, 4)
        poly1d([0])

    polydiv(u, v)
        Returns the quotient and remainder of polynomial division.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        The input arrays are the coefficients (including any coefficients
        equal to zero) of the "numerator" (dividend) and "denominator"
        (divisor) polynomials, respectively.

        Parameters
        ----------
        u : array_like or poly1d
            Dividend polynomial's coefficients.

        v : array_like or poly1d
            Divisor polynomial's coefficients.

        Returns
        -------
        q : ndarray
            Coefficients, including those equal to zero, of the quotient.
        r : ndarray
            Coefficients, including those equal to zero, of the remainder.

        See Also
        --------
        poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
        polyval

        Notes
        -----
        Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
        not equal `v.ndim`. In other words, all four possible combinations -
        ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
        ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.

        Examples
        --------
        .. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25

        >>> import numpy as np
        >>> x = np.array([3.0, 5.0, 2.0])
        >>> y = np.array([2.0, 1.0])
        >>> np.polydiv(x, y)
        (array([1.5 , 1.75]), array([0.25]))

    polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False)
        Least squares polynomial fit.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`
        to points `(x, y)`. Returns a vector of coefficients `p` that minimises
        the squared error in the order `deg`, `deg-1`, ... `0`.

        The `Polynomial.fit <numpy.polynomial.polynomial.Polynomial.fit>` class
        method is recommended for new code as it is more stable numerically. See
        the documentation of the method for more information.

        Parameters
        ----------
        x : array_like, shape (M,)
            x-coordinates of the M sample points ``(x[i], y[i])``.
        y : array_like, shape (M,) or (M, K)
            y-coordinates of the sample points. Several data sets of sample
            points sharing the same x-coordinates can be fitted at once by
            passing in a 2D-array that contains one dataset per column.
        deg : int
            Degree of the fitting polynomial
        rcond : float, optional
            Relative condition number of the fit. Singular values smaller than
            this relative to the largest singular value will be ignored. The
            default value is len(x)*eps, where eps is the relative precision of
            the float type, about 2e-16 in most cases.
        full : bool, optional
            Switch determining nature of return value. When it is False (the
            default) just the coefficients are returned, when True diagnostic
            information from the singular value decomposition is also returned.
        w : array_like, shape (M,), optional
            Weights. If not None, the weight ``w[i]`` applies to the unsquared
            residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
            chosen so that the errors of the products ``w[i]*y[i]`` all have the
            same variance.  When using inverse-variance weighting, use
            ``w[i] = 1/sigma(y[i])``.  The default value is None.
        cov : bool or str, optional
            If given and not `False`, return not just the estimate but also its
            covariance matrix. By default, the covariance are scaled by
            chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed
            to be unreliable except in a relative sense and everything is scaled
            such that the reduced chi2 is unity. This scaling is omitted if
            ``cov='unscaled'``, as is relevant for the case that the weights are
            w = 1/sigma, with sigma known to be a reliable estimate of the
            uncertainty.

        Returns
        -------
        p : ndarray, shape (deg + 1,) or (deg + 1, K)
            Polynomial coefficients, highest power first.  If `y` was 2-D, the
            coefficients for `k`-th data set are in ``p[:,k]``.

        residuals, rank, singular_values, rcond
            These values are only returned if ``full == True``

            - residuals -- sum of squared residuals of the least squares fit
            - rank -- the effective rank of the scaled Vandermonde
               coefficient matrix
            - singular_values -- singular values of the scaled Vandermonde
               coefficient matrix
            - rcond -- value of `rcond`.

            For more details, see `numpy.linalg.lstsq`.

        V : ndarray, shape (deg + 1, deg + 1) or (deg + 1, deg + 1, K)
            Present only if ``full == False`` and ``cov == True``.  The covariance
            matrix of the polynomial coefficient estimates.  The diagonal of
            this matrix are the variance estimates for each coefficient.  If y
            is a 2-D array, then the covariance matrix for the `k`-th data set
            are in ``V[:,:,k]``


        Warns
        -----
        RankWarning
            The rank of the coefficient matrix in the least-squares fit is
            deficient. The warning is only raised if ``full == False``.

            The warnings can be turned off by

            >>> import warnings
            >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)

        See Also
        --------
        polyval : Compute polynomial values.
        linalg.lstsq : Computes a least-squares fit.
        scipy.interpolate.UnivariateSpline : Computes spline fits.

        Notes
        -----
        The solution minimizes the squared error

        .. math::
            E = \sum_{j=0}^k |p(x_j) - y_j|^2

        in the equations::

            x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
            x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
            ...
            x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]

        The coefficient matrix of the coefficients `p` is a Vandermonde matrix.

        `polyfit` issues a `~exceptions.RankWarning` when the least-squares fit is
        badly conditioned. This implies that the best fit is not well-defined due
        to numerical error. The results may be improved by lowering the polynomial
        degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
        can also be set to a value smaller than its default, but the resulting
        fit may be spurious: including contributions from the small singular
        values can add numerical noise to the result.

        Note that fitting polynomial coefficients is inherently badly conditioned
        when the degree of the polynomial is large or the interval of sample points
        is badly centered. The quality of the fit should always be checked in these
        cases. When polynomial fits are not satisfactory, splines may be a good
        alternative.

        References
        ----------
        .. [1] Wikipedia, "Curve fitting",
               https://en.wikipedia.org/wiki/Curve_fitting
        .. [2] Wikipedia, "Polynomial interpolation",
               https://en.wikipedia.org/wiki/Polynomial_interpolation

        Examples
        --------
        >>> import numpy as np
        >>> import warnings
        >>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
        >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
        >>> z = np.polyfit(x, y, 3)
        >>> z
        array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254]) # may vary

        It is convenient to use `poly1d` objects for dealing with polynomials:

        >>> p = np.poly1d(z)
        >>> p(0.5)
        0.6143849206349179 # may vary
        >>> p(3.5)
        -0.34732142857143039 # may vary
        >>> p(10)
        22.579365079365115 # may vary

        High-order polynomials may oscillate wildly:

        >>> with warnings.catch_warnings():
        ...     warnings.simplefilter('ignore', np.exceptions.RankWarning)
        ...     p30 = np.poly1d(np.polyfit(x, y, 30))
        ...
        >>> p30(4)
        -0.80000000000000204 # may vary
        >>> p30(5)
        -0.99999999999999445 # may vary
        >>> p30(4.5)
        -0.10547061179440398 # may vary

        Illustration:

        >>> import matplotlib.pyplot as plt
        >>> xp = np.linspace(-2, 6, 100)
        >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
        >>> plt.ylim(-2,2)
        (-2, 2)
        >>> plt.show()

    polyint(p, m=1, k=None)
        Return an antiderivative (indefinite integral) of a polynomial.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        The returned order `m` antiderivative `P` of polynomial `p` satisfies
        :math:`\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
        integration constants `k`. The constants determine the low-order
        polynomial part

        .. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1}

        of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.

        Parameters
        ----------
        p : array_like or poly1d
            Polynomial to integrate.
            A sequence is interpreted as polynomial coefficients, see `poly1d`.
        m : int, optional
            Order of the antiderivative. (Default: 1)
        k : list of `m` scalars or scalar, optional
            Integration constants. They are given in the order of integration:
            those corresponding to highest-order terms come first.

            If ``None`` (default), all constants are assumed to be zero.
            If `m = 1`, a single scalar can be given instead of a list.

        See Also
        --------
        polyder : derivative of a polynomial
        poly1d.integ : equivalent method

        Examples
        --------
        The defining property of the antiderivative:

        >>> import numpy as np

        >>> p = np.poly1d([1,1,1])
        >>> P = np.polyint(p)
        >>> P
         poly1d([ 0.33333333,  0.5       ,  1.        ,  0.        ]) # may vary
        >>> np.polyder(P) == p
        True

        The integration constants default to zero, but can be specified:

        >>> P = np.polyint(p, 3)
        >>> P(0)
        0.0
        >>> np.polyder(P)(0)
        0.0
        >>> np.polyder(P, 2)(0)
        0.0
        >>> P = np.polyint(p, 3, k=[6,5,3])
        >>> P
        poly1d([ 0.01666667,  0.04166667,  0.16666667,  3. ,  5. ,  3. ]) # may vary

        Note that 3 = 6 / 2!, and that the constants are given in the order of
        integrations. Constant of the highest-order polynomial term comes first:

        >>> np.polyder(P, 2)(0)
        6.0
        >>> np.polyder(P, 1)(0)
        5.0
        >>> P(0)
        3.0

    polymul(a1, a2)
        Find the product of two polynomials.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        Finds the polynomial resulting from the multiplication of the two input
        polynomials. Each input must be either a poly1d object or a 1D sequence
        of polynomial coefficients, from highest to lowest degree.

        Parameters
        ----------
        a1, a2 : array_like or poly1d object
            Input polynomials.

        Returns
        -------
        out : ndarray or poly1d object
            The polynomial resulting from the multiplication of the inputs. If
            either inputs is a poly1d object, then the output is also a poly1d
            object. Otherwise, it is a 1D array of polynomial coefficients from
            highest to lowest degree.

        See Also
        --------
        poly1d : A one-dimensional polynomial class.
        poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
        convolve : Array convolution. Same output as polymul, but has parameter
                   for overlap mode.

        Examples
        --------
        >>> import numpy as np
        >>> np.polymul([1, 2, 3], [9, 5, 1])
        array([ 9, 23, 38, 17,  3])

        Using poly1d objects:

        >>> p1 = np.poly1d([1, 2, 3])
        >>> p2 = np.poly1d([9, 5, 1])
        >>> print(p1)
           2
        1 x + 2 x + 3
        >>> print(p2)
           2
        9 x + 5 x + 1
        >>> print(np.polymul(p1, p2))
           4      3      2
        9 x + 23 x + 38 x + 17 x + 3

    polysub(a1, a2)
        Difference (subtraction) of two polynomials.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        Given two polynomials `a1` and `a2`, returns ``a1 - a2``.
        `a1` and `a2` can be either array_like sequences of the polynomials'
        coefficients (including coefficients equal to zero), or `poly1d` objects.

        Parameters
        ----------
        a1, a2 : array_like or poly1d
            Minuend and subtrahend polynomials, respectively.

        Returns
        -------
        out : ndarray or poly1d
            Array or `poly1d` object of the difference polynomial's coefficients.

        See Also
        --------
        polyval, polydiv, polymul, polyadd

        Examples
        --------
        .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)

        >>> import numpy as np

        >>> np.polysub([2, 10, -2], [3, 10, -4])
        array([-1,  0,  2])

    polyval(p, x)
        Evaluate a polynomial at specific values.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        If `p` is of length N, this function returns the value::

            p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]

        If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``.
        If `x` is another polynomial then the composite polynomial ``p(x(t))``
        is returned.

        Parameters
        ----------
        p : array_like or poly1d object
           1D array of polynomial coefficients (including coefficients equal
           to zero) from highest degree to the constant term, or an
           instance of poly1d.
        x : array_like or poly1d object
           A number, an array of numbers, or an instance of poly1d, at
           which to evaluate `p`.

        Returns
        -------
        values : ndarray or poly1d
           If `x` is a poly1d instance, the result is the composition of the two
           polynomials, i.e., `x` is "substituted" in `p` and the simplified
           result is returned. In addition, the type of `x` - array_like or
           poly1d - governs the type of the output: `x` array_like => `values`
           array_like, `x` a poly1d object => `values` is also.

        See Also
        --------
        poly1d: A polynomial class.

        Notes
        -----
        Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
        for polynomials of high degree the values may be inaccurate due to
        rounding errors. Use carefully.

        If `x` is a subtype of `ndarray` the return value will be of the same type.

        References
        ----------
        .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
           trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
           Reinhold Co., 1985, pg. 720.

        Examples
        --------
        >>> import numpy as np
        >>> np.polyval([3,0,1], 5)  # 3 * 5**2 + 0 * 5**1 + 1
        76
        >>> np.polyval([3,0,1], np.poly1d(5))
        poly1d([76])
        >>> np.polyval(np.poly1d([3,0,1]), 5)
        76
        >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
        poly1d([76])

    printoptions(*args, **kwargs)
        Context manager for setting print options.

        Set print options for the scope of the `with` block, and restore the old
        options at the end. See `set_printoptions` for the full description of
        available options.

        Examples
        --------
        >>> import numpy as np

        >>> from numpy.testing import assert_equal
        >>> with np.printoptions(precision=2):
        ...     np.array([2.0]) / 3
        array([0.67])

        The `as`-clause of the `with`-statement gives the current print options:

        >>> with np.printoptions(precision=2) as opts:
        ...      assert_equal(opts, np.get_printoptions())

        See Also
        --------
        set_printoptions, get_printoptions

    prod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Return the product of array elements over a given axis.

        Parameters
        ----------
        a : array_like
            Input data.
        axis : None or int or tuple of ints, optional
            Axis or axes along which a product is performed.  The default,
            axis=None, will calculate the product of all the elements in the
            input array. If axis is negative it counts from the last to the
            first axis.

            .. versionadded:: 1.7.0

            If axis is a tuple of ints, a product is performed on all of the
            axes specified in the tuple instead of a single axis or all the
            axes as before.
        dtype : dtype, optional
            The type of the returned array, as well as of the accumulator in
            which the elements are multiplied.  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.
        out : ndarray, optional
            Alternative output array 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.
        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 `prod` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.
        initial : scalar, optional
            The starting value for this product. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.15.0

        where : array_like of bool, optional
            Elements to include in the product. See `~numpy.ufunc.reduce`
            for details.

            .. versionadded:: 1.17.0

        Returns
        -------
        product_along_axis : ndarray, see `dtype` parameter above.
            An array shaped as `a` but with the specified axis removed.
            Returns a reference to `out` if specified.

        See Also
        --------
        ndarray.prod : equivalent method
        :ref:`ufuncs-output-type`

        Notes
        -----
        Arithmetic is modular when using integer types, and no error is
        raised on overflow.  That means that, on a 32-bit platform:

        >>> x = np.array([536870910, 536870910, 536870910, 536870910])
        >>> np.prod(x)
        16 # may vary

        The product of an empty array is the neutral element 1:

        >>> np.prod([])
        1.0

        Examples
        --------
        By default, calculate the product of all elements:

        >>> import numpy as np
        >>> np.prod([1.,2.])
        2.0

        Even when the input array is two-dimensional:

        >>> a = np.array([[1., 2.], [3., 4.]])
        >>> np.prod(a)
        24.0

        But we can also specify the axis over which to multiply:

        >>> np.prod(a, axis=1)
        array([  2.,  12.])
        >>> np.prod(a, axis=0)
        array([3., 8.])

        Or select specific elements to include:

        >>> np.prod([1., np.nan, 3.], where=[True, False, True])
        3.0

        If the type of `x` is unsigned, then the output type is
        the unsigned platform integer:

        >>> x = np.array([1, 2, 3], dtype=np.uint8)
        >>> np.prod(x).dtype == np.uint
        True

        If `x` is of a signed integer type, then the output type
        is the default platform integer:

        >>> x = np.array([1, 2, 3], dtype=np.int8)
        >>> np.prod(x).dtype == int
        True

        You can also start the product with a value other than one:

        >>> np.prod([1, 2], initial=5)
        10

    promote_types(...)
        promote_types(type1, type2)

        Returns the data type with the smallest size and smallest scalar
        kind to which both ``type1`` and ``type2`` may be safely cast.
        The returned data type is always considered "canonical", this mainly
        means that the promoted dtype will always be in native byte order.

        This function is symmetric, but rarely associative.

        Parameters
        ----------
        type1 : dtype or dtype specifier
            First data type.
        type2 : dtype or dtype specifier
            Second data type.

        Returns
        -------
        out : dtype
            The promoted data type.

        Notes
        -----
        Please see `numpy.result_type` for additional information about promotion.

        .. versionadded:: 1.6.0

        Starting in NumPy 1.9, promote_types function now returns a valid string
        length when given an integer or float dtype as one argument and a string
        dtype as another argument. Previously it always returned the input string
        dtype, even if it wasn't long enough to store the max integer/float value
        converted to a string.

        .. versionchanged:: 1.23.0

        NumPy now supports promotion for more structured dtypes.  It will now
        remove unnecessary padding from a structure dtype and promote included
        fields individually.

        See Also
        --------
        result_type, dtype, can_cast

        Examples
        --------
        >>> import numpy as np
        >>> np.promote_types('f4', 'f8')
        dtype('float64')

        >>> np.promote_types('i8', 'f4')
        dtype('float64')

        >>> np.promote_types('>i8', '<c8')
        dtype('complex128')

        >>> np.promote_types('i4', 'S8')
        dtype('S11')

        An example of a non-associative case:

        >>> p = np.promote_types
        >>> p('S', p('i1', 'u1'))
        dtype('S6')
        >>> p(p('S', 'i1'), 'u1')
        dtype('S4')

    ptp(a, axis=None, out=None, keepdims=<no value>)
        Range of values (maximum - minimum) along an axis.

        The name of the function comes from the acronym for 'peak to peak'.

        .. warning::
            `ptp` preserves the data type of the array. This means the
            return value for an input of signed integers with n bits
            (e.g. `numpy.int8`, `numpy.int16`, etc) is also a signed integer
            with n bits.  In that case, peak-to-peak values greater than
            ``2**(n-1)-1`` will be returned as negative values. An example
            with a work-around is shown below.

        Parameters
        ----------
        a : array_like
            Input values.
        axis : None or int or tuple of ints, optional
            Axis along which to find the peaks.  By default, flatten the
            array.  `axis` may be negative, in
            which case it counts from the last to the first axis.

            .. versionadded:: 1.15.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 : array_like
            Alternative output array in which to place the result. It must
            have the same shape and buffer length as the expected output,
            but the type of the output values will be cast if necessary.

        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 `ptp` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.

        Returns
        -------
        ptp : ndarray or scalar
            The range of a given array - `scalar` if array is one-dimensional
            or a new array holding the result along the given axis

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([[4, 9, 2, 10],
        ...               [6, 9, 7, 12]])

        >>> np.ptp(x, axis=1)
        array([8, 6])

        >>> np.ptp(x, axis=0)
        array([2, 0, 5, 2])

        >>> np.ptp(x)
        10

        This example shows that a negative value can be returned when
        the input is an array of signed integers.

        >>> y = np.array([[1, 127],
        ...               [0, 127],
        ...               [-1, 127],
        ...               [-2, 127]], dtype=np.int8)
        >>> np.ptp(y, axis=1)
        array([ 126,  127, -128, -127], dtype=int8)

        A work-around is to use the `view()` method to view the result as
        unsigned integers with the same bit width:

        >>> np.ptp(y, axis=1).view(np.uint8)
        array([126, 127, 128, 129], dtype=uint8)

    put(a, ind, v, mode='raise')
        Replaces specified elements of an array with given values.

        The indexing works on the flattened target array. `put` is roughly
        equivalent to:

        ::

            a.flat[ind] = v

        Parameters
        ----------
        a : ndarray
            Target array.
        ind : array_like
            Target indices, interpreted as integers.
        v : array_like
            Values to place in `a` at target indices. If `v` is shorter than
            `ind` it will be repeated as necessary.
        mode : {'raise', 'wrap', 'clip'}, optional
            Specifies how out-of-bounds indices will behave.

            * 'raise' -- raise an error (default)
            * 'wrap' -- wrap around
            * 'clip' -- clip to the range

            'clip' mode means that all indices that are too large are replaced
            by the index that addresses the last element along that axis. Note
            that this disables indexing with negative numbers. In 'raise' mode,
            if an exception occurs the target array may still be modified.

        See Also
        --------
        putmask, place
        put_along_axis : Put elements by matching the array and the index arrays

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(5)
        >>> np.put(a, [0, 2], [-44, -55])
        >>> a
        array([-44,   1, -55,   3,   4])

        >>> a = np.arange(5)
        >>> np.put(a, 22, -5, mode='clip')
        >>> a
        array([ 0,  1,  2,  3, -5])

    put_along_axis(arr, indices, values, axis)
        Put values into the destination array by matching 1d index and data slices.

        This iterates over matching 1d slices oriented along the specified axis in
        the index and data arrays, and uses the former to place values into the
        latter. These slices can be different lengths.

        Functions returning an index along an axis, like `argsort` and
        `argpartition`, produce suitable indices for this function.

        .. versionadded:: 1.15.0

        Parameters
        ----------
        arr : ndarray (Ni..., M, Nk...)
            Destination array.
        indices : ndarray (Ni..., J, Nk...)
            Indices to change along each 1d slice of `arr`. This must match the
            dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
            against `arr`.
        values : array_like (Ni..., J, Nk...)
            values to insert at those indices. Its shape and dimension are
            broadcast to match that of `indices`.
        axis : int
            The axis to take 1d slices along. If axis is None, the destination
            array is treated as if a flattened 1d view had been created of it.

        Notes
        -----
        This is equivalent to (but faster than) the following use of `ndindex` and
        `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::

            Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
            J = indices.shape[axis]  # Need not equal M

            for ii in ndindex(Ni):
                for kk in ndindex(Nk):
                    a_1d       = a      [ii + s_[:,] + kk]
                    indices_1d = indices[ii + s_[:,] + kk]
                    values_1d  = values [ii + s_[:,] + kk]
                    for j in range(J):
                        a_1d[indices_1d[j]] = values_1d[j]

        Equivalently, eliminating the inner loop, the last two lines would be::

                    a_1d[indices_1d] = values_1d

        See Also
        --------
        take_along_axis :
            Take values from the input array by matching 1d index and data slices

        Examples
        --------
        >>> import numpy as np

        For this sample array

        >>> a = np.array([[10, 30, 20], [60, 40, 50]])

        We can replace the maximum values with:

        >>> ai = np.argmax(a, axis=1, keepdims=True)
        >>> ai
        array([[1],
               [0]])
        >>> np.put_along_axis(a, ai, 99, axis=1)
        >>> a
        array([[10, 99, 20],
               [99, 40, 50]])

    putmask(...)
        putmask(a, mask, values)

        Changes elements of an array based on conditional and input values.

        Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.

        If `values` is not the same size as `a` and `mask` then it will repeat.
        This gives behavior different from ``a[mask] = values``.

        Parameters
        ----------
        a : ndarray
            Target array.
        mask : array_like
            Boolean mask array. It has to be the same shape as `a`.
        values : array_like
            Values to put into `a` where `mask` is True. If `values` is smaller
            than `a` it will be repeated.

        See Also
        --------
        place, put, take, copyto

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(6).reshape(2, 3)
        >>> np.putmask(x, x>2, x**2)
        >>> x
        array([[ 0,  1,  2],
               [ 9, 16, 25]])

        If `values` is smaller than `a` it is repeated:

        >>> x = np.arange(5)
        >>> np.putmask(x, x>1, [-33, -44])
        >>> x
        array([  0,   1, -33, -44, -33])

    quantile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None, interpolation=None)
        Compute the q-th quantile of the data along the specified axis.

        .. versionadded:: 1.15.0

        Parameters
        ----------
        a : array_like of real numbers
            Input array or object that can be converted to an array.
        q : array_like of float
            Probability or sequence of probabilities of the quantiles to compute.
            Values must be between 0 and 1 inclusive.
        axis : {int, tuple of int, None}, optional
            Axis or axes along which the quantiles are computed. The default is
            to compute the quantile(s) along a flattened version of the array.
        out : ndarray, optional
            Alternative output array in which to place the result. It must have
            the same shape and buffer length as the expected output, but the
            type (of the output) will be cast if necessary.
        overwrite_input : bool, optional
            If True, then allow the input array `a` to be modified by
            intermediate calculations, to save memory. In this case, the
            contents of the input `a` after this function completes is
            undefined.
        method : str, optional
            This parameter specifies the method to use for estimating the
            quantile.  There are many different methods, some unique to NumPy.
            The recommended options, numbered as they appear in [1]_, are:

            1. 'inverted_cdf'
            2. 'averaged_inverted_cdf'
            3. 'closest_observation'
            4. 'interpolated_inverted_cdf'
            5. 'hazen'
            6. 'weibull'
            7. 'linear'  (default)
            8. 'median_unbiased'
            9. 'normal_unbiased'

            The first three methods are discontinuous. For backward compatibility
            with previous versions of NumPy, the following discontinuous variations
            of the default 'linear' (7.) option are available:

            * 'lower'
            * 'higher',
            * 'midpoint'
            * 'nearest'

            See Notes for details.

            .. versionchanged:: 1.22.0
                This argument was previously called "interpolation" and only
                offered the "linear" default and last four options.

        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 `a`.

        weights : array_like, optional
            An array of weights associated with the values in `a`. Each value in
            `a` contributes to the quantile according to its associated weight.
            The weights array can either be 1-D (in which case its length must be
            the size of `a` along the given axis) or of the same shape as `a`.
            If `weights=None`, then all data in `a` are assumed to have a
            weight equal to one.
            Only `method="inverted_cdf"` supports weights.
            See the notes for more details.

            .. versionadded:: 2.0.0

        interpolation : str, optional
            Deprecated name for the method keyword argument.

            .. deprecated:: 1.22.0

        Returns
        -------
        quantile : scalar or ndarray
            If `q` is a single probability and `axis=None`, then the result
            is a scalar. If multiple probability levels are given, first axis
            of the result corresponds to the quantiles. The other axes are
            the axes that remain after the reduction of `a`. If the input
            contains integers or floats smaller than ``float64``, the output
            data-type is ``float64``. Otherwise, the output data-type is the
            same as that of the input. If `out` is specified, that array is
            returned instead.

        See Also
        --------
        mean
        percentile : equivalent to quantile, but with q in the range [0, 100].
        median : equivalent to ``quantile(..., 0.5)``
        nanquantile

        Notes
        -----
        Given a sample `a` from an underlying distribution, `quantile` provides a
        nonparametric estimate of the inverse cumulative distribution function.

        By default, this is done by interpolating between adjacent elements in
        ``y``, a sorted copy of `a`::

            (1-g)*y[j] + g*y[j+1]

        where the index ``j`` and coefficient ``g`` are the integral and
        fractional components of ``q * (n-1)``, and ``n`` is the number of
        elements in the sample.

        This is a special case of Equation 1 of H&F [1]_. More generally,

        - ``j = (q*n + m - 1) // 1``, and
        - ``g = (q*n + m - 1) % 1``,

        where ``m`` may be defined according to several different conventions.
        The preferred convention may be selected using the ``method`` parameter:

        =============================== =============== ===============
        ``method``                      number in H&F   ``m``
        =============================== =============== ===============
        ``interpolated_inverted_cdf``   4               ``0``
        ``hazen``                       5               ``1/2``
        ``weibull``                     6               ``q``
        ``linear`` (default)            7               ``1 - q``
        ``median_unbiased``             8               ``q/3 + 1/3``
        ``normal_unbiased``             9               ``q/4 + 3/8``
        =============================== =============== ===============

        Note that indices ``j`` and ``j + 1`` are clipped to the range ``0`` to
        ``n - 1`` when the results of the formula would be outside the allowed
        range of non-negative indices. The ``- 1`` in the formulas for ``j`` and
        ``g`` accounts for Python's 0-based indexing.

        The table above includes only the estimators from H&F that are continuous
        functions of probability `q` (estimators 4-9). NumPy also provides the
        three discontinuous estimators from H&F (estimators 1-3), where ``j`` is
        defined as above, ``m`` is defined as follows, and ``g`` is a function
        of the real-valued ``index = q*n + m - 1`` and ``j``.

        1. ``inverted_cdf``: ``m = 0`` and ``g = int(index - j > 0)``
        2. ``averaged_inverted_cdf``: ``m = 0`` and
           ``g = (1 + int(index - j > 0)) / 2``
        3. ``closest_observation``: ``m = -1/2`` and
           ``g = 1 - int((index == j) & (j%2 == 1))``

        For backward compatibility with previous versions of NumPy, `quantile`
        provides four additional discontinuous estimators. Like
        ``method='linear'``, all have ``m = 1 - q`` so that ``j = q*(n-1) // 1``,
        but ``g`` is defined as follows.

        - ``lower``: ``g = 0``
        - ``midpoint``: ``g = 0.5``
        - ``higher``: ``g = 1``
        - ``nearest``: ``g = (q*(n-1) % 1) > 0.5``

        **Weighted quantiles:**
        More formally, the quantile at probability level :math:`q` of a cumulative
        distribution function :math:`F(y)=P(Y \leq y)` with probability measure
        :math:`P` is defined as any number :math:`x` that fulfills the
        *coverage conditions*

        .. math:: P(Y < x) \leq q \quad\text{and}\quad P(Y \leq x) \geq q

        with random variable :math:`Y\sim P`.
        Sample quantiles, the result of `quantile`, provide nonparametric
        estimation of the underlying population counterparts, represented by the
        unknown :math:`F`, given a data vector `a` of length ``n``.

        Some of the estimators above arise when one considers :math:`F` as the
        empirical distribution function of the data, i.e.
        :math:`F(y) = \frac{1}{n} \sum_i 1_{a_i \leq y}`.
        Then, different methods correspond to different choices of :math:`x` that
        fulfill the above coverage conditions. Methods that follow this approach
        are ``inverted_cdf`` and ``averaged_inverted_cdf``.

        For weighted quantiles, the coverage conditions still hold. The
        empirical cumulative distribution is simply replaced by its weighted
        version, i.e.
        :math:`P(Y \leq t) = \frac{1}{\sum_i w_i} \sum_i w_i 1_{x_i \leq t}`.
        Only ``method="inverted_cdf"`` supports weights.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[10, 7, 4], [3, 2, 1]])
        >>> a
        array([[10,  7,  4],
               [ 3,  2,  1]])
        >>> np.quantile(a, 0.5)
        3.5
        >>> np.quantile(a, 0.5, axis=0)
        array([6.5, 4.5, 2.5])
        >>> np.quantile(a, 0.5, axis=1)
        array([7.,  2.])
        >>> np.quantile(a, 0.5, axis=1, keepdims=True)
        array([[7.],
               [2.]])
        >>> m = np.quantile(a, 0.5, axis=0)
        >>> out = np.zeros_like(m)
        >>> np.quantile(a, 0.5, axis=0, out=out)
        array([6.5, 4.5, 2.5])
        >>> m
        array([6.5, 4.5, 2.5])
        >>> b = a.copy()
        >>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
        array([7.,  2.])
        >>> assert not np.all(a == b)

        See also `numpy.percentile` for a visualization of most methods.

        References
        ----------
        .. [1] R. J. Hyndman and Y. Fan,
           "Sample quantiles in statistical packages,"
           The American Statistician, 50(4), pp. 361-365, 1996

    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
            y is a contiguous 1-D array of the same subtype as `a`,
            with shape ``(a.size,)``.
            Note that matrices are special cased for backward compatibility,
            if `a` is a matrix, then y is a 1-D ndarray.

        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. However, ``ravel`` supports ``K`` in the optional
        ``order`` argument while ``reshape`` does not.

        Examples
        --------
        It is equivalent to ``reshape(-1, order=order)``.

        >>> import numpy as np
        >>> x = np.array([[1, 2, 3], [4, 5, 6]])
        >>> np.ravel(x)
        array([1, 2, 3, 4, 5, 6])

        >>> x.reshape(-1)
        array([1, 2, 3, 4, 5, 6])

        >>> np.ravel(x, order='F')
        array([1, 4, 2, 5, 3, 6])

        When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:

        >>> np.ravel(x.T)
        array([1, 4, 2, 5, 3, 6])
        >>> np.ravel(x.T, order='A')
        array([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])

    ravel_multi_index(...)
        ravel_multi_index(multi_index, dims, mode='raise', order='C')

        Converts a tuple of index arrays into an array of flat
        indices, applying boundary modes to the multi-index.

        Parameters
        ----------
        multi_index : tuple of array_like
            A tuple of integer arrays, one array for each dimension.
        dims : tuple of ints
            The shape of array into which the indices from ``multi_index`` apply.
        mode : {'raise', 'wrap', 'clip'}, optional
            Specifies how out-of-bounds indices are handled.  Can specify
            either one mode or a tuple of modes, one mode per index.

            * 'raise' -- raise an error (default)
            * 'wrap' -- wrap around
            * 'clip' -- clip to the range

            In 'clip' mode, a negative index which would normally
            wrap will clip to 0 instead.
        order : {'C', 'F'}, optional
            Determines whether the multi-index should be viewed as
            indexing in row-major (C-style) or column-major
            (Fortran-style) order.

        Returns
        -------
        raveled_indices : ndarray
            An array of indices into the flattened version of an array
            of dimensions ``dims``.

        See Also
        --------
        unravel_index

        Notes
        -----
        .. versionadded:: 1.6.0

        Examples
        --------
        >>> import numpy as np
        >>> arr = np.array([[3,6,6],[4,5,1]])
        >>> np.ravel_multi_index(arr, (7,6))
        array([22, 41, 37])
        >>> np.ravel_multi_index(arr, (7,6), order='F')
        array([31, 41, 13])
        >>> np.ravel_multi_index(arr, (4,6), mode='clip')
        array([22, 23, 19])
        >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
        array([12, 13, 13])

        >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
        1621

    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
        --------
        >>> import numpy as np
        >>> 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

    real_if_close(a, tol=100)
        If input is complex with all imaginary parts close to zero, return
        real parts.

        "Close to zero" is defined as `tol` * (machine epsilon of the type for
        `a`).

        Parameters
        ----------
        a : array_like
            Input array.
        tol : float
            Tolerance in machine epsilons for the complex part of the elements
            in the array. If the tolerance is <=1, then the absolute tolerance
            is used.

        Returns
        -------
        out : ndarray
            If `a` is real, the type of `a` is used for the output.  If `a`
            has complex elements, the returned type is float.

        See Also
        --------
        real, imag, angle

        Notes
        -----
        Machine epsilon varies from machine to machine and between data types
        but Python floats on most platforms have a machine epsilon equal to
        2.2204460492503131e-16.  You can use 'np.finfo(float).eps' to print
        out the machine epsilon for floats.

        Examples
        --------
        >>> import numpy as np
        >>> np.finfo(float).eps
        2.2204460492503131e-16 # may vary

        >>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)
        array([2.1, 5.2])
        >>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
        array([2.1+4.e-13j, 5.2 + 3e-15j])

    repeat(a, repeats, axis=None)
        Repeat each element of an array after themselves

        Parameters
        ----------
        a : array_like
            Input array.
        repeats : int or array of ints
            The number of repetitions for each element.  `repeats` is broadcasted
            to fit the shape of the given axis.
        axis : int, optional
            The axis along which to repeat values.  By default, use the
            flattened input array, and return a flat output array.

        Returns
        -------
        repeated_array : ndarray
            Output array which has the same shape as `a`, except along
            the given axis.

        See Also
        --------
        tile : Tile an array.
        unique : Find the unique elements of an array.

        Examples
        --------
        >>> import numpy as np
        >>> np.repeat(3, 4)
        array([3, 3, 3, 3])
        >>> x = np.array([[1,2],[3,4]])
        >>> np.repeat(x, 2)
        array([1, 1, 2, 2, 3, 3, 4, 4])
        >>> np.repeat(x, 3, axis=1)
        array([[1, 1, 1, 2, 2, 2],
               [3, 3, 3, 4, 4, 4]])
        >>> np.repeat(x, [1, 2], axis=0)
        array([[1, 2],
               [3, 4],
               [3, 4]])

    require(a, dtype=None, requirements=None, *, like=None)
        Return an ndarray of the provided type that satisfies requirements.

        This function is useful to be sure that an array with the correct flags
        is returned for passing to compiled code (perhaps through ctypes).

        Parameters
        ----------
        a : array_like
           The object to be converted to a type-and-requirement-satisfying array.
        dtype : data-type
           The required data-type. If None preserve the current dtype. If your
           application requires the data to be in native byteorder, include
           a byteorder specification as a part of the dtype specification.
        requirements : str or sequence of str
           The requirements list can be any of the following

           * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
           * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
           * 'ALIGNED' ('A')      - ensure a data-type aligned array
           * 'WRITEABLE' ('W')    - ensure a writable array
           * 'OWNDATA' ('O')      - ensure an array that owns its own data
           * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Array with specified requirements and type if given.

        See Also
        --------
        asarray : Convert input to an ndarray.
        asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
        ascontiguousarray : Convert input to a contiguous array.
        asfortranarray : Convert input to an ndarray with column-major
                         memory order.
        ndarray.flags : Information about the memory layout of the array.

        Notes
        -----
        The returned array will be guaranteed to have the listed requirements
        by making a copy if needed.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(6).reshape(2,3)
        >>> x.flags
          C_CONTIGUOUS : True
          F_CONTIGUOUS : False
          OWNDATA : False
          WRITEABLE : True
          ALIGNED : True
          WRITEBACKIFCOPY : False

        >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
        >>> y.flags
          C_CONTIGUOUS : False
          F_CONTIGUOUS : True
          OWNDATA : True
          WRITEABLE : True
          ALIGNED : True
          WRITEBACKIFCOPY : False

    reshape(a, /, shape=None, order='C', *, newshape=None, copy=None)
        Gives a new shape to an array without changing its data.

        Parameters
        ----------
        a : array_like
            Array to be reshaped.
        shape : int or tuple of ints
            The new shape should be compatible with the original shape. If
            an integer, then the result will be a 1-D array of that length.
            One shape dimension can be -1. In this case, the value is
            inferred from the length of the array and remaining dimensions.
        order : {'C', 'F', 'A'}, optional
            Read the elements of ``a`` using this index order, and place the
            elements into the reshaped array using this index order. 'C'
            means to read / write the elements using C-like index order,
            with the last axis index changing fastest, back to the first
            axis index changing slowest. 'F' means to read / write the
            elements using Fortran-like index 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 indexing.
            'A' means to read / write the elements in Fortran-like index
            order if ``a`` is Fortran *contiguous* in memory, C-like order
            otherwise.
        newshape : int or tuple of ints
            .. deprecated:: 2.1
                Replaced by ``shape`` argument. Retained for backward
                compatibility.
        copy : bool, optional
            If ``True``, then the array data is copied. If ``None``, a copy will
            only be made if it's required by ``order``. For ``False`` it raises
            a ``ValueError`` if a copy cannot be avoided. Default: ``None``.

        Returns
        -------
        reshaped_array : ndarray
            This will be a new view object if possible; otherwise, it will
            be a copy.  Note there is no guarantee of the *memory layout* (C- or
            Fortran- contiguous) of the returned array.

        See Also
        --------
        ndarray.reshape : Equivalent method.

        Notes
        -----
        It is not always possible to change the shape of an array without copying
        the data.

        The ``order`` keyword gives the index ordering both for *fetching*
        the values from ``a``, and then *placing* the values into the output
        array. For example, let's say you have an array:

        >>> a = np.arange(6).reshape((3, 2))
        >>> a
        array([[0, 1],
               [2, 3],
               [4, 5]])

        You can think of reshaping as first raveling the array (using the given
        index order), then inserting the elements from the raveled array into the
        new array using the same kind of index ordering as was used for the
        raveling.

        >>> np.reshape(a, (2, 3)) # C-like index ordering
        array([[0, 1, 2],
               [3, 4, 5]])
        >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
        array([[0, 1, 2],
               [3, 4, 5]])
        >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
        array([[0, 4, 3],
               [2, 1, 5]])
        >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
        array([[0, 4, 3],
               [2, 1, 5]])

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1,2,3], [4,5,6]])
        >>> np.reshape(a, 6)
        array([1, 2, 3, 4, 5, 6])
        >>> np.reshape(a, 6, order='F')
        array([1, 4, 2, 5, 3, 6])

        >>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
        array([[1, 2],
               [3, 4],
               [5, 6]])

    resize(a, new_shape)
        Return a new array with the specified shape.

        If the new array is larger than the original array, then the new
        array is filled with repeated copies of `a`.  Note that this behavior
        is different from a.resize(new_shape) which fills with zeros instead
        of repeated copies of `a`.

        Parameters
        ----------
        a : array_like
            Array to be resized.

        new_shape : int or tuple of int
            Shape of resized array.

        Returns
        -------
        reshaped_array : ndarray
            The new array is formed from the data in the old array, repeated
            if necessary to fill out the required number of elements.  The
            data are repeated iterating over the array in C-order.

        See Also
        --------
        numpy.reshape : Reshape an array without changing the total size.
        numpy.pad : Enlarge and pad an array.
        numpy.repeat : Repeat elements of an array.
        ndarray.resize : resize an array in-place.

        Notes
        -----
        When the total size of the array does not change `~numpy.reshape` should
        be used.  In most other cases either indexing (to reduce the size)
        or padding (to increase the size) may be a more appropriate solution.

        Warning: This functionality does **not** consider axes separately,
        i.e. it does not apply interpolation/extrapolation.
        It fills the return array with the required number of elements, iterating
        over `a` in C-order, disregarding axes (and cycling back from the start if
        the new shape is larger).  This functionality is therefore not suitable to
        resize images, or data where each axis represents a separate and distinct
        entity.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[0,1],[2,3]])
        >>> np.resize(a,(2,3))
        array([[0, 1, 2],
               [3, 0, 1]])
        >>> np.resize(a,(1,4))
        array([[0, 1, 2, 3]])
        >>> np.resize(a,(2,4))
        array([[0, 1, 2, 3],
               [0, 1, 2, 3]])

    result_type(...)
        result_type(*arrays_and_dtypes)

        Returns the type that results from applying the NumPy
        type promotion rules to the arguments.

        Type promotion in NumPy works similarly to the rules in languages
        like C++, with some slight differences.  When both scalars and
        arrays are used, the array's type takes precedence and the actual value
        of the scalar is taken into account.

        For example, calculating 3*a, where a is an array of 32-bit floats,
        intuitively should result in a 32-bit float output.  If the 3 is a
        32-bit integer, the NumPy rules indicate it can't convert losslessly
        into a 32-bit float, so a 64-bit float should be the result type.
        By examining the value of the constant, '3', we see that it fits in
        an 8-bit integer, which can be cast losslessly into the 32-bit float.

        Parameters
        ----------
        arrays_and_dtypes : list of arrays and dtypes
            The operands of some operation whose result type is needed.

        Returns
        -------
        out : dtype
            The result type.

        See also
        --------
        dtype, promote_types, min_scalar_type, can_cast

        Notes
        -----
        .. versionadded:: 1.6.0

        The specific algorithm used is as follows.

        Categories are determined by first checking which of boolean,
        integer (int/uint), or floating point (float/complex) the maximum
        kind of all the arrays and the scalars are.

        If there are only scalars or the maximum category of the scalars
        is higher than the maximum category of the arrays,
        the data types are combined with :func:`promote_types`
        to produce the return value.

        Otherwise, `min_scalar_type` is called on each scalar, and
        the resulting data types are all combined with :func:`promote_types`
        to produce the return value.

        The set of int values is not a subset of the uint values for types
        with the same number of bits, something not reflected in
        :func:`min_scalar_type`, but handled as a special case in `result_type`.

        Examples
        --------
        >>> import numpy as np
        >>> np.result_type(3, np.arange(7, dtype='i1'))
        dtype('int8')

        >>> np.result_type('i4', 'c8')
        dtype('complex128')

        >>> np.result_type(3.0, -2)
        dtype('float64')

    roll(a, shift, axis=None)
        Roll array elements along a given axis.

        Elements that roll beyond the last position are re-introduced at
        the first.

        Parameters
        ----------
        a : array_like
            Input array.
        shift : int or tuple of ints
            The number of places by which elements are shifted.  If a tuple,
            then `axis` must be a tuple of the same size, and each of the
            given axes is shifted by the corresponding number.  If an int
            while `axis` is a tuple of ints, then the same value is used for
            all given axes.
        axis : int or tuple of ints, optional
            Axis or axes along which elements are shifted.  By default, the
            array is flattened before shifting, after which the original
            shape is restored.

        Returns
        -------
        res : ndarray
            Output array, with the same shape as `a`.

        See Also
        --------
        rollaxis : Roll the specified axis backwards, until it lies in a
                   given position.

        Notes
        -----
        .. versionadded:: 1.12.0

        Supports rolling over multiple dimensions simultaneously.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(10)
        >>> np.roll(x, 2)
        array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
        >>> np.roll(x, -2)
        array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])

        >>> x2 = np.reshape(x, (2, 5))
        >>> x2
        array([[0, 1, 2, 3, 4],
               [5, 6, 7, 8, 9]])
        >>> np.roll(x2, 1)
        array([[9, 0, 1, 2, 3],
               [4, 5, 6, 7, 8]])
        >>> np.roll(x2, -1)
        array([[1, 2, 3, 4, 5],
               [6, 7, 8, 9, 0]])
        >>> np.roll(x2, 1, axis=0)
        array([[5, 6, 7, 8, 9],
               [0, 1, 2, 3, 4]])
        >>> np.roll(x2, -1, axis=0)
        array([[5, 6, 7, 8, 9],
               [0, 1, 2, 3, 4]])
        >>> np.roll(x2, 1, axis=1)
        array([[4, 0, 1, 2, 3],
               [9, 5, 6, 7, 8]])
        >>> np.roll(x2, -1, axis=1)
        array([[1, 2, 3, 4, 0],
               [6, 7, 8, 9, 5]])
        >>> np.roll(x2, (1, 1), axis=(1, 0))
        array([[9, 5, 6, 7, 8],
               [4, 0, 1, 2, 3]])
        >>> np.roll(x2, (2, 1), axis=(1, 0))
        array([[8, 9, 5, 6, 7],
               [3, 4, 0, 1, 2]])

    rollaxis(a, axis, start=0)
        Roll the specified axis backwards, until it lies in a given position.

        This function continues to be supported for backward compatibility, but you
        should prefer `moveaxis`. The `moveaxis` function was added in NumPy
        1.11.

        Parameters
        ----------
        a : ndarray
            Input array.
        axis : int
            The axis to be rolled. The positions of the other axes do not
            change relative to one another.
        start : int, optional
            When ``start <= axis``, the axis is rolled back until it lies in
            this position. When ``start > axis``, the axis is rolled until it
            lies before this position. The default, 0, results in a "complete"
            roll. The following table describes how negative values of ``start``
            are interpreted:

            .. table::
               :align: left

               +-------------------+----------------------+
               |     ``start``     | Normalized ``start`` |
               +===================+======================+
               | ``-(arr.ndim+1)`` | raise ``AxisError``  |
               +-------------------+----------------------+
               | ``-arr.ndim``     | 0                    |
               +-------------------+----------------------+
               | |vdots|           | |vdots|              |
               +-------------------+----------------------+
               | ``-1``            | ``arr.ndim-1``       |
               +-------------------+----------------------+
               | ``0``             | ``0``                |
               +-------------------+----------------------+
               | |vdots|           | |vdots|              |
               +-------------------+----------------------+
               | ``arr.ndim``      | ``arr.ndim``         |
               +-------------------+----------------------+
               | ``arr.ndim + 1``  | raise ``AxisError``  |
               +-------------------+----------------------+

            .. |vdots|   unicode:: U+22EE .. Vertical Ellipsis

        Returns
        -------
        res : ndarray
            For NumPy >= 1.10.0 a view of `a` is always returned. 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.

        See Also
        --------
        moveaxis : Move array axes to new positions.
        roll : Roll the elements of an array by a number of positions along a
            given axis.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.ones((3,4,5,6))
        >>> np.rollaxis(a, 3, 1).shape
        (3, 6, 4, 5)
        >>> np.rollaxis(a, 2).shape
        (5, 3, 4, 6)
        >>> np.rollaxis(a, 1, 4).shape
        (3, 5, 6, 4)

    roots(p)
        Return the roots of a polynomial with coefficients given in p.

        .. note::
           This forms part of the old polynomial API. Since version 1.4, the
           new polynomial API defined in `numpy.polynomial` is preferred.
           A summary of the differences can be found in the
           :doc:`transition guide </reference/routines.polynomials>`.

        The values in the rank-1 array `p` are coefficients of a polynomial.
        If the length of `p` is n+1 then the polynomial is described by::

          p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]

        Parameters
        ----------
        p : array_like
            Rank-1 array of polynomial coefficients.

        Returns
        -------
        out : ndarray
            An array containing the roots of the polynomial.

        Raises
        ------
        ValueError
            When `p` cannot be converted to a rank-1 array.

        See also
        --------
        poly : Find the coefficients of a polynomial with a given sequence
               of roots.
        polyval : Compute polynomial values.
        polyfit : Least squares polynomial fit.
        poly1d : A one-dimensional polynomial class.

        Notes
        -----
        The algorithm relies on computing the eigenvalues of the
        companion matrix [1]_.

        References
        ----------
        .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
            Cambridge University Press, 1999, pp. 146-7.

        Examples
        --------
        >>> import numpy as np
        >>> coeff = [3.2, 2, 1]
        >>> np.roots(coeff)
        array([-0.3125+0.46351241j, -0.3125-0.46351241j])

    rot90(m, k=1, axes=(0, 1))
        Rotate an array by 90 degrees in the plane specified by axes.

        Rotation direction is from the first towards the second axis.
        This means for a 2D array with the default `k` and `axes`, the
        rotation will be counterclockwise.

        Parameters
        ----------
        m : array_like
            Array of two or more dimensions.
        k : integer
            Number of times the array is rotated by 90 degrees.
        axes : (2,) array_like
            The array is rotated in the plane defined by the axes.
            Axes must be different.

            .. versionadded:: 1.12.0

        Returns
        -------
        y : ndarray
            A rotated view of `m`.

        See Also
        --------
        flip : Reverse the order of elements in an array along the given axis.
        fliplr : Flip an array horizontally.
        flipud : Flip an array vertically.

        Notes
        -----
        ``rot90(m, k=1, axes=(1,0))``  is the reverse of
        ``rot90(m, k=1, axes=(0,1))``

        ``rot90(m, k=1, axes=(1,0))`` is equivalent to
        ``rot90(m, k=-1, axes=(0,1))``

        Examples
        --------
        >>> import numpy as np
        >>> m = np.array([[1,2],[3,4]], int)
        >>> m
        array([[1, 2],
               [3, 4]])
        >>> np.rot90(m)
        array([[2, 4],
               [1, 3]])
        >>> np.rot90(m, 2)
        array([[4, 3],
               [2, 1]])
        >>> m = np.arange(8).reshape((2,2,2))
        >>> np.rot90(m, 1, (1,2))
        array([[[1, 3],
                [0, 2]],
               [[5, 7],
                [4, 6]]])

    round(a, decimals=0, out=None)
        Evenly round to the given number of decimals.

        Parameters
        ----------
        a : array_like
            Input data.
        decimals : int, optional
            Number of decimal places to round to (default: 0).  If
            decimals is negative, it specifies the number of positions to
            the left of the decimal point.
        out : ndarray, optional
            Alternative output array 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. See :ref:`ufuncs-output-type`
            for more details.

        Returns
        -------
        rounded_array : ndarray
            An array of the same type as `a`, containing the rounded values.
            Unless `out` was specified, a new array is created.  A reference to
            the result is returned.

            The real and imaginary parts of complex numbers are rounded
            separately.  The result of rounding a float is a float.

        See Also
        --------
        ndarray.round : equivalent method
        around : an alias for this function
        ceil, fix, floor, rint, trunc


        Notes
        -----
        For values exactly halfway between rounded decimal values, NumPy
        rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
        -0.5 and 0.5 round to 0.0, etc.

        ``np.round`` uses a fast but sometimes inexact algorithm to round
        floating-point datatypes. For positive `decimals` it is equivalent to
        ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has
        error due to the inexact representation of decimal fractions in the IEEE
        floating point standard [1]_ and errors introduced when scaling by powers
        of ten. For instance, note the extra "1" in the following:

            >>> np.round(56294995342131.5, 3)
            56294995342131.51

        If your goal is to print such values with a fixed number of decimals, it is
        preferable to use numpy's float printing routines to limit the number of
        printed decimals:

            >>> np.format_float_positional(56294995342131.5, precision=3)
            '56294995342131.5'

        The float printing routines use an accurate but much more computationally
        demanding algorithm to compute the number of digits after the decimal
        point.

        Alternatively, Python's builtin `round` function uses a more accurate
        but slower algorithm for 64-bit floating point values:

            >>> round(56294995342131.5, 3)
            56294995342131.5
            >>> np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
            (16.06, 16.05)


        References
        ----------
        .. [1] "Lecture Notes on the Status of IEEE 754", William Kahan,
               https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF

        Examples
        --------
        >>> import numpy as np
        >>> np.round([0.37, 1.64])
        array([0., 2.])
        >>> np.round([0.37, 1.64], decimals=1)
        array([0.4, 1.6])
        >>> np.round([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
        array([0., 2., 2., 4., 4.])
        >>> np.round([1,2,3,11], decimals=1) # ndarray of ints is returned
        array([ 1,  2,  3, 11])
        >>> np.round([1,2,3,11], decimals=-1)
        array([ 0,  0,  0, 10])

    row_stack(tup, *, dtype=None, casting='same_kind')
        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.

        dtype : str or dtype
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`.

            .. versionadded:: 1.24

        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur. Defaults to 'same_kind'.

            .. versionadded:: 1.24

        Returns
        -------
        stacked : ndarray
            The array formed by stacking the given arrays, will be at least 2-D.

        See Also
        --------
        concatenate : Join a sequence of arrays along an existing axis.
        stack : Join a sequence of arrays along a new axis.
        block : Assemble an nd-array from nested lists of blocks.
        hstack : Stack arrays in sequence horizontally (column wise).
        dstack : Stack arrays in sequence depth wise (along third axis).
        column_stack : Stack 1-D arrays as columns into a 2-D array.
        vsplit : Split an array into multiple sub-arrays vertically (row-wise).
        unstack : Split an array into a tuple of sub-arrays along an axis.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1, 2, 3])
        >>> b = np.array([4, 5, 6])
        >>> np.vstack((a,b))
        array([[1, 2, 3],
               [4, 5, 6]])

        >>> a = np.array([[1], [2], [3]])
        >>> b = np.array([[4], [5], [6]])
        >>> np.vstack((a,b))
        array([[1],
               [2],
               [3],
               [4],
               [5],
               [6]])

    save(file, arr, allow_pickle=True, fix_imports=<no value>)
        Save an array to a binary file in NumPy ``.npy`` format.

        Parameters
        ----------
        file : file, str, or pathlib.Path
            File or filename to which the data is saved. If file is a file-object,
            then the filename is unchanged.  If file is a string or Path,
            a ``.npy`` extension will be appended to the filename if it does not
            already have one.
        arr : array_like
            Array data to be saved.
        allow_pickle : bool, optional
            Allow saving object arrays using Python pickles. Reasons for
            disallowing pickles include security (loading pickled data can execute
            arbitrary code) and portability (pickled objects may not be loadable
            on different Python installations, for example if the stored objects
            require libraries that are not available, and not all pickled data is
            compatible between different versions of Python).
            Default: True
        fix_imports : bool, optional
            The `fix_imports` flag is deprecated and has no effect.

            .. deprecated:: 2.1
                This flag is ignored since NumPy 1.17 and was only needed to
                support loading some files in Python 2 written in Python 3.

        See Also
        --------
        savez : Save several arrays into a ``.npz`` archive
        savetxt, load

        Notes
        -----
        For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.

        Any data saved to the file is appended to the end of the file.

        Examples
        --------
        >>> import numpy as np

        >>> from tempfile import TemporaryFile
        >>> outfile = TemporaryFile()

        >>> x = np.arange(10)
        >>> np.save(outfile, x)

        >>> _ = outfile.seek(0) # Only needed to simulate closing & reopening file
        >>> np.load(outfile)
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])


        >>> with open('test.npy', 'wb') as f:
        ...     np.save(f, np.array([1, 2]))
        ...     np.save(f, np.array([1, 3]))
        >>> with open('test.npy', 'rb') as f:
        ...     a = np.load(f)
        ...     b = np.load(f)
        >>> print(a, b)
        # [1 2] [1 3]

    savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)
        Save an array to a text file.

        Parameters
        ----------
        fname : filename, file handle or pathlib.Path
            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 single specifier, ``fmt='%.4e'``, resulting in numbers formatted
              like ``' (%s+%sj)' % (fmt, fmt)``
            * a full string specifying every real and imaginary part, e.g.
              ``' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'`` for 3 columns
            * 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
               <https://docs.python.org/library/string.html#format-specification-mini-language>`_,
               Python Documentation.

        Examples
        --------
        >>> import numpy as np
        >>> 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

    savez(file, *args, **kwds)
        Save several arrays into a single file in uncompressed ``.npz`` format.

        Provide arrays as keyword arguments to store them under the
        corresponding name in the output file: ``savez(fn, x=x, y=y)``.

        If arrays are specified as positional arguments, i.e., ``savez(fn,
        x, y)``, their names will be `arr_0`, `arr_1`, etc.

        Parameters
        ----------
        file : file, str, or pathlib.Path
            Either the filename (string) or an open file (file-like object)
            where the data will be saved. If file is a string or a Path, the
            ``.npz`` extension will be appended to the filename if it is not
            already there.
        args : Arguments, optional
            Arrays to save to the file. Please use keyword arguments (see
            `kwds` below) to assign names to arrays.  Arrays specified as
            args will be named "arr_0", "arr_1", and so on.
        kwds : Keyword arguments, optional
            Arrays to save to the file. Each array will be saved to the
            output file with its corresponding keyword name.

        Returns
        -------
        None

        See Also
        --------
        save : Save a single array to a binary file in NumPy format.
        savetxt : Save an array to a file as plain text.
        savez_compressed : Save several arrays into a compressed ``.npz`` archive

        Notes
        -----
        The ``.npz`` file format is a zipped archive of files named after the
        variables they contain.  The archive is not compressed and each file
        in the archive contains one variable in ``.npy`` format. For a
        description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.

        When opening the saved ``.npz`` file with `load` a `~lib.npyio.NpzFile`
        object is returned. This is a dictionary-like object which can be queried
        for its list of arrays (with the ``.files`` attribute), and for the arrays
        themselves.

        Keys passed in `kwds` are used as filenames inside the ZIP archive.
        Therefore, keys should be valid filenames; e.g., avoid keys that begin with
        ``/`` or contain ``.``.

        When naming variables with keyword arguments, it is not possible to name a
        variable ``file``, as this would cause the ``file`` argument to be defined
        twice in the call to ``savez``.

        Examples
        --------
        >>> import numpy as np
        >>> from tempfile import TemporaryFile
        >>> outfile = TemporaryFile()
        >>> x = np.arange(10)
        >>> y = np.sin(x)

        Using `savez` with \*args, the arrays are saved with default names.

        >>> np.savez(outfile, x, y)
        >>> _ = outfile.seek(0) # Only needed to simulate closing & reopening file
        >>> npzfile = np.load(outfile)
        >>> npzfile.files
        ['arr_0', 'arr_1']
        >>> npzfile['arr_0']
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

        Using `savez` with \**kwds, the arrays are saved with the keyword names.

        >>> outfile = TemporaryFile()
        >>> np.savez(outfile, x=x, y=y)
        >>> _ = outfile.seek(0)
        >>> npzfile = np.load(outfile)
        >>> sorted(npzfile.files)
        ['x', 'y']
        >>> npzfile['x']
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

    savez_compressed(file, *args, **kwds)
        Save several arrays into a single file in compressed ``.npz`` format.

        Provide arrays as keyword arguments to store them under the
        corresponding name in the output file: ``savez_compressed(fn, x=x, y=y)``.

        If arrays are specified as positional arguments, i.e.,
        ``savez_compressed(fn, x, y)``, their names will be `arr_0`, `arr_1`, etc.

        Parameters
        ----------
        file : file, str, or pathlib.Path
            Either the filename (string) or an open file (file-like object)
            where the data will be saved. If file is a string or a Path, the
            ``.npz`` extension will be appended to the filename if it is not
            already there.
        args : Arguments, optional
            Arrays to save to the file. Please use keyword arguments (see
            `kwds` below) to assign names to arrays.  Arrays specified as
            args will be named "arr_0", "arr_1", and so on.
        kwds : Keyword arguments, optional
            Arrays to save to the file. Each array will be saved to the
            output file with its corresponding keyword name.

        Returns
        -------
        None

        See Also
        --------
        numpy.save : Save a single array to a binary file in NumPy format.
        numpy.savetxt : Save an array to a file as plain text.
        numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
        numpy.load : Load the files created by savez_compressed.

        Notes
        -----
        The ``.npz`` file format is a zipped archive of files named after the
        variables they contain.  The archive is compressed with
        ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
        in ``.npy`` format. For a description of the ``.npy`` format, see
        :py:mod:`numpy.lib.format`.


        When opening the saved ``.npz`` file with `load` a `~lib.npyio.NpzFile`
        object is returned. This is a dictionary-like object which can be queried
        for its list of arrays (with the ``.files`` attribute), and for the arrays
        themselves.

        Examples
        --------
        >>> import numpy as np
        >>> test_array = np.random.rand(3, 2)
        >>> test_vector = np.random.rand(4)
        >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
        >>> loaded = np.load('/tmp/123.npz')
        >>> print(np.array_equal(test_array, loaded['a']))
        True
        >>> print(np.array_equal(test_vector, loaded['b']))
        True

    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.

        Assuming that `a` is sorted:

        ======  ============================
        `side`  returned index `i` satisfies
        ======  ============================
        left    ``a[i-1] < v <= a[i]``
        right   ``a[i-1] <= v < a[i]``
        ======  ============================

        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 : int or array of ints
            Array of insertion points with the same shape as `v`,
            or an integer if `v` is a scalar.

        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`.

        This function uses the same algorithm as the builtin python
        `bisect.bisect_left` (``side='left'``) and `bisect.bisect_right`
        (``side='right'``) functions, which is also vectorized
        in the `v` argument.

        Examples
        --------
        >>> import numpy as np
        >>> np.searchsorted([11,12,13,14,15], 13)
        2
        >>> np.searchsorted([11,12,13,14,15], 13, side='right')
        3
        >>> np.searchsorted([11,12,13,14,15], [-10, 20, 12, 13])
        array([0, 5, 1, 2])

    select(condlist, choicelist, default=0)
        Return an array drawn from elements in choicelist, depending on conditions.

        Parameters
        ----------
        condlist : list of bool ndarrays
            The list of conditions which determine from which array in `choicelist`
            the output elements are taken. When multiple conditions are satisfied,
            the first one encountered in `condlist` is used.
        choicelist : list of ndarrays
            The list of arrays from which the output elements are taken. It has
            to be of the same length as `condlist`.
        default : scalar, optional
            The element inserted in `output` when all conditions evaluate to False.

        Returns
        -------
        output : ndarray
            The output at position m is the m-th element of the array in
            `choicelist` where the m-th element of the corresponding array in
            `condlist` is True.

        See Also
        --------
        where : Return elements from one of two arrays depending on condition.
        take, choose, compress, diag, diagonal

        Examples
        --------
        >>> import numpy as np

        Beginning with an array of integers from 0 to 5 (inclusive),
        elements less than ``3`` are negated, elements greater than ``3``
        are squared, and elements not meeting either of these conditions
        (exactly ``3``) are replaced with a `default` value of ``42``.

        >>> x = np.arange(6)
        >>> condlist = [x<3, x>3]
        >>> choicelist = [x, x**2]
        >>> np.select(condlist, choicelist, 42)
        array([ 0,  1,  2, 42, 16, 25])

        When multiple conditions are satisfied, the first one encountered in
        `condlist` is used.

        >>> condlist = [x<=4, x>3]
        >>> choicelist = [x, x**2]
        >>> np.select(condlist, choicelist, 55)
        array([ 0,  1,  2,  3,  4, 25])

    set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None, override_repr=None)
        Set printing options.

        These options determine the way floating point numbers, arrays and
        other NumPy objects are displayed.

        Parameters
        ----------
        precision : int or None, optional
            Number of digits of precision for floating point output (default 8).
            May be None if `floatmode` is not `fixed`, to print as many digits as
            necessary to uniquely specify the value.
        threshold : int, optional
            Total number of array elements which trigger summarization
            rather than full repr (default 1000).
            To always use the full repr without summarization, pass `sys.maxsize`.
        edgeitems : int, optional
            Number of array items in summary at beginning and end of
            each dimension (default 3).
        linewidth : int, optional
            The number of characters per line for the purpose of inserting
            line breaks (default 75).
        suppress : bool, optional
            If True, always print floating point numbers using fixed point
            notation, in which case numbers equal to zero in the current precision
            will print as zero.  If False, then scientific notation is used when
            absolute value of the smallest number is < 1e-4 or the ratio of the
            maximum absolute value to the minimum is > 1e3. The default is False.
        nanstr : str, optional
            String representation of floating point not-a-number (default nan).
        infstr : str, optional
            String representation of floating point infinity (default inf).
        sign : string, either '-', '+', or ' ', optional
            Controls printing of the sign of floating-point types. If '+', always
            print the sign of positive values. If ' ', always prints a space
            (whitespace character) in the sign position of positive values.  If
            '-', omit the sign character of positive values. (default '-')

            .. versionchanged:: 2.0
                 The sign parameter can now be an integer type, previously
                 types were floating-point types.

        formatter : dict of callables, optional
            If not None, the keys should indicate the type(s) that the respective
            formatting function applies to.  Callables should return a string.
            Types that are not specified (by their corresponding keys) are handled
            by the default formatters.  Individual types for which a formatter
            can be set are:

            - 'bool'
            - 'int'
            - 'timedelta' : a `numpy.timedelta64`
            - 'datetime' : a `numpy.datetime64`
            - 'float'
            - 'longfloat' : 128-bit floats
            - 'complexfloat'
            - 'longcomplexfloat' : composed of two 128-bit floats
            - 'numpystr' : types `numpy.bytes_` and `numpy.str_`
            - 'object' : `np.object_` arrays

            Other keys that can be used to set a group of types at once are:

            - 'all' : sets all types
            - 'int_kind' : sets 'int'
            - 'float_kind' : sets 'float' and 'longfloat'
            - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
            - 'str_kind' : sets 'numpystr'
        floatmode : str, optional
            Controls the interpretation of the `precision` option for
            floating-point types. Can take the following values
            (default maxprec_equal):

            * 'fixed': Always print exactly `precision` fractional digits,
                    even if this would print more or fewer digits than
                    necessary to specify the value uniquely.
            * 'unique': Print the minimum number of fractional digits necessary
                    to represent each value uniquely. Different elements may
                    have a different number of digits. The value of the
                    `precision` option is ignored.
            * 'maxprec': Print at most `precision` fractional digits, but if
                    an element can be uniquely represented with fewer digits
                    only print it with that many.
            * 'maxprec_equal': Print at most `precision` fractional digits,
                    but if every element in the array can be uniquely
                    represented with an equal number of fewer digits, use that
                    many digits for all elements.
        legacy : string or `False`, optional
            If set to the string ``'1.13'`` enables 1.13 legacy printing mode. This
            approximates numpy 1.13 print output by including a space in the sign
            position of floats and different behavior for 0d arrays. This also
            enables 1.21 legacy printing mode (described below).

            If set to the string ``'1.21'`` enables 1.21 legacy printing mode. This
            approximates numpy 1.21 print output of complex structured dtypes
            by not inserting spaces after commas that separate fields and after
            colons.

            If set to ``'1.25'`` approximates printing of 1.25 which mainly means
            that numeric scalars are printed without their type information, e.g.
            as ``3.0`` rather than ``np.float64(3.0)``.

            If set to `False`, disables legacy mode.

            Unrecognized strings will be ignored with a warning for forward
            compatibility.

            .. versionadded:: 1.14.0
            .. versionchanged:: 1.22.0
            .. versionchanged:: 2.0

        override_repr: callable, optional
            If set a passed function will be used for generating arrays' repr.
            Other options will be ignored.

        See Also
        --------
        get_printoptions, printoptions, array2string

        Notes
        -----
        `formatter` is always reset with a call to `set_printoptions`.

        Use `printoptions` as a context manager to set the values temporarily.

        Examples
        --------
        Floating point precision can be set:

        >>> import numpy as np
        >>> np.set_printoptions(precision=4)
        >>> np.array([1.123456789])
        [1.1235]

        Long arrays can be summarised:

        >>> np.set_printoptions(threshold=5)
        >>> np.arange(10)
        array([0, 1, 2, ..., 7, 8, 9])

        Small results can be suppressed:

        >>> eps = np.finfo(float).eps
        >>> x = np.arange(4.)
        >>> x**2 - (x + eps)**2
        array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
        >>> np.set_printoptions(suppress=True)
        >>> x**2 - (x + eps)**2
        array([-0., -0.,  0.,  0.])

        A custom formatter can be used to display array elements as desired:

        >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
        >>> x = np.arange(3)
        >>> x
        array([int: 0, int: -1, int: -2])
        >>> np.set_printoptions()  # formatter gets reset
        >>> x
        array([0, 1, 2])

        To put back the default options, you can use:

        >>> np.set_printoptions(edgeitems=3, infstr='inf',
        ... linewidth=75, nanstr='nan', precision=8,
        ... suppress=False, threshold=1000, formatter=None)

        Also to temporarily override options, use `printoptions`
        as a context manager:

        >>> with np.printoptions(precision=2, suppress=True, threshold=5):
        ...     np.linspace(0, 10, 10)
        array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])

    setbufsize(size)
        Set the size of the buffer used in ufuncs.

        .. versionchanged:: 2.0
            The scope of setting the buffer is tied to the `numpy.errstate`
            context.  Exiting a ``with errstate():`` will also restore the bufsize.

        Parameters
        ----------
        size : int
            Size of buffer.

        Returns
        -------
        bufsize : int
            Previous size of ufunc buffer in bytes.

        Examples
        --------
        When exiting a `numpy.errstate` context manager the bufsize is restored:

        >>> import numpy as np
        >>> with np.errstate():
        ...     np.setbufsize(4096)
        ...     print(np.getbufsize())
        ...
        8192
        4096
        >>> np.getbufsize()
        8192

    setdiff1d(ar1, ar2, assume_unique=False)
        Find the set difference of two arrays.

        Return the unique values in `ar1` that are not in `ar2`.

        Parameters
        ----------
        ar1 : array_like
            Input array.
        ar2 : array_like
            Input comparison array.
        assume_unique : bool
            If True, the input arrays are both assumed to be unique, which
            can speed up the calculation.  Default is False.

        Returns
        -------
        setdiff1d : ndarray
            1D array of values in `ar1` that are not in `ar2`. The result
            is sorted when `assume_unique=False`, but otherwise only sorted
            if the input is sorted.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1, 2, 3, 2, 4, 1])
        >>> b = np.array([3, 4, 5, 6])
        >>> np.setdiff1d(a, b)
        array([1, 2])

    seterr(all=None, divide=None, over=None, under=None, invalid=None)
        Set how floating-point errors are handled.

        Note that operations on integer scalar types (such as `int16`) are
        handled like floating point, and are affected by these settings.

        Parameters
        ----------
        all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
            Set treatment for all types of floating-point errors at once:

            - ignore: Take no action when the exception occurs.
            - warn: Print a :exc:`RuntimeWarning` (via the Python `warnings`
              module).
            - raise: Raise a :exc:`FloatingPointError`.
            - call: Call a function specified using the `seterrcall` function.
            - print: Print a warning directly to ``stdout``.
            - log: Record error in a Log object specified by `seterrcall`.

            The default is not to change the current behavior.
        divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
            Treatment for division by zero.
        over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
            Treatment for floating-point overflow.
        under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
            Treatment for floating-point underflow.
        invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
            Treatment for invalid floating-point operation.

        Returns
        -------
        old_settings : dict
            Dictionary containing the old settings.

        See also
        --------
        seterrcall : Set a callback function for the 'call' mode.
        geterr, geterrcall, errstate

        Notes
        -----
        The floating-point exceptions are defined in the IEEE 754 standard [1]_:

        - Division by zero: infinite result obtained from finite numbers.
        - Overflow: result too large to be expressed.
        - Underflow: result so close to zero that some precision
          was lost.
        - Invalid operation: result is not an expressible number, typically
          indicates that a NaN was produced.

        .. [1] https://en.wikipedia.org/wiki/IEEE_754

        Examples
        --------
        >>> import numpy as np
        >>> orig_settings = np.seterr(all='ignore')  # seterr to known value
        >>> np.int16(32000) * np.int16(3)
        30464
        >>> np.seterr(over='raise')
        {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
        >>> old_settings = np.seterr(all='warn', over='raise')
        >>> np.int16(32000) * np.int16(3)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        FloatingPointError: overflow encountered in scalar multiply

        >>> old_settings = np.seterr(all='print')
        >>> np.geterr()
        {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
        >>> np.int16(32000) * np.int16(3)
        30464
        >>> np.seterr(**orig_settings)  # restore original
        {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}

    seterrcall(func)
        Set the floating-point error callback function or log object.

        There are two ways to capture floating-point error messages.  The first
        is to set the error-handler to 'call', using `seterr`.  Then, set
        the function to call using this function.

        The second is to set the error-handler to 'log', using `seterr`.
        Floating-point errors then trigger a call to the 'write' method of
        the provided object.

        Parameters
        ----------
        func : callable f(err, flag) or object with write method
            Function to call upon floating-point errors ('call'-mode) or
            object whose 'write' method is used to log such message ('log'-mode).

            The call function takes two arguments. The first is a string describing
            the type of error (such as "divide by zero", "overflow", "underflow",
            or "invalid value"), and the second is the status flag.  The flag is a
            byte, whose four least-significant bits indicate the type of error, one
            of "divide", "over", "under", "invalid"::

              [0 0 0 0 divide over under invalid]

            In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.

            If an object is provided, its write method should take one argument,
            a string.

        Returns
        -------
        h : callable, log instance or None
            The old error handler.

        See Also
        --------
        seterr, geterr, geterrcall

        Examples
        --------
        Callback upon error:

        >>> def err_handler(type, flag):
        ...     print("Floating point error (%s), with flag %s" % (type, flag))
        ...

        >>> import numpy as np

        >>> orig_handler = np.seterrcall(err_handler)
        >>> orig_err = np.seterr(all='call')

        >>> np.array([1, 2, 3]) / 0.0
        Floating point error (divide by zero), with flag 1
        array([inf, inf, inf])

        >>> np.seterrcall(orig_handler)
        <function err_handler at 0x...>
        >>> np.seterr(**orig_err)
        {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}

        Log error message:

        >>> class Log:
        ...     def write(self, msg):
        ...         print("LOG: %s" % msg)
        ...

        >>> log = Log()
        >>> saved_handler = np.seterrcall(log)
        >>> save_err = np.seterr(all='log')

        >>> np.array([1, 2, 3]) / 0.0
        LOG: Warning: divide by zero encountered in divide
        array([inf, inf, inf])

        >>> np.seterrcall(orig_handler)
        <numpy.Log object at 0x...>
        >>> np.seterr(**orig_err)
        {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}

    setxor1d(ar1, ar2, assume_unique=False)
        Find the set exclusive-or of two arrays.

        Return the sorted, unique values that are in only one (not both) of the
        input arrays.

        Parameters
        ----------
        ar1, ar2 : array_like
            Input arrays.
        assume_unique : bool
            If True, the input arrays are both assumed to be unique, which
            can speed up the calculation. Default is False.

        Returns
        -------
        setxor1d : ndarray
            Sorted 1D array of unique values that are in only one of the input
            arrays.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1, 2, 3, 2, 4])
        >>> b = np.array([2, 3, 5, 7, 5])
        >>> np.setxor1d(a,b)
        array([1, 4, 5, 7])

    shape(a)
        Return the shape of an array.

        Parameters
        ----------
        a : array_like
            Input array.

        Returns
        -------
        shape : tuple of ints
            The elements of the shape tuple give the lengths of the
            corresponding array dimensions.

        See Also
        --------
        len : ``len(a)`` is equivalent to ``np.shape(a)[0]`` for N-D arrays with
              ``N>=1``.
        ndarray.shape : Equivalent array method.

        Examples
        --------
        >>> import numpy as np
        >>> np.shape(np.eye(3))
        (3, 3)
        >>> np.shape([[1, 3]])
        (1, 2)
        >>> np.shape([0])
        (1,)
        >>> np.shape(0)
        ()

        >>> a = np.array([(1, 2), (3, 4), (5, 6)],
        ...              dtype=[('x', 'i4'), ('y', 'i4')])
        >>> np.shape(a)
        (3,)
        >>> a.shape
        (3,)

    shares_memory(...)
        shares_memory(a, b, /, max_work=None)

        Determine if two arrays share memory.

        .. warning::

           This function can be exponentially slow for some inputs, unless
           `max_work` is set to zero or a positive integer.
           If in doubt, use `numpy.may_share_memory` instead.

        Parameters
        ----------
        a, b : ndarray
            Input arrays
        max_work : int, optional
            Effort to spend on solving the overlap problem (maximum number
            of candidate solutions to consider). The following special
            values are recognized:

            max_work=-1 (default)
                The problem is solved exactly. In this case, the function returns
                True only if there is an element shared between the arrays. Finding
                the exact solution may take extremely long in some cases.
            max_work=0
                Only the memory bounds of a and b are checked.
                This is equivalent to using ``may_share_memory()``.

        Raises
        ------
        numpy.exceptions.TooHardError
            Exceeded max_work.

        Returns
        -------
        out : bool

        See Also
        --------
        may_share_memory

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([1, 2, 3, 4])
        >>> np.shares_memory(x, np.array([5, 6, 7]))
        False
        >>> np.shares_memory(x[::2], x)
        True
        >>> np.shares_memory(x[::2], x[1::2])
        False

        Checking whether two arrays share memory is NP-complete, and
        runtime may increase exponentially in the number of
        dimensions. Hence, `max_work` should generally be set to a finite
        number, as it is possible to construct examples that take
        extremely long to run:

        >>> from numpy.lib.stride_tricks import as_strided
        >>> x = np.zeros([192163377], dtype=np.int8)
        >>> x1 = as_strided(
        ...     x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049))
        >>> x2 = as_strided(
        ...     x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1))
        >>> np.shares_memory(x1, x2, max_work=1000)
        Traceback (most recent call last):
        ...
        numpy.exceptions.TooHardError: Exceeded max_work

        Running ``np.shares_memory(x1, x2)`` without `max_work` set takes
        around 1 minute for this case. It is possible to find problems
        that take still significantly longer.

    show_config = show(mode='stdout')
        Show libraries and system information on which NumPy was built
        and is being used

        Parameters
        ----------
        mode : {`'stdout'`, `'dicts'`}, optional.
            Indicates how to display the config information.
            `'stdout'` prints to console, `'dicts'` returns a dictionary
            of the configuration.

        Returns
        -------
        out : {`dict`, `None`}
            If mode is `'dicts'`, a dict is returned, else None

        See Also
        --------
        get_include : Returns the directory containing NumPy C
                      header files.

        Notes
        -----
        1. The `'stdout'` mode will give more readable
           output if ``pyyaml`` is installed

    show_runtime()
        Print information about various resources in the system
        including available intrinsic support and BLAS/LAPACK library
        in use

        .. versionadded:: 1.24.0

        See Also
        --------
        show_config : Show libraries in the system on which NumPy was built.

        Notes
        -----
        1. Information is derived with the help of `threadpoolctl <https://pypi.org/project/threadpoolctl/>`_
           library if available.
        2. SIMD related information is derived from ``__cpu_features__``,
           ``__cpu_baseline__`` and ``__cpu_dispatch__``

    sinc(x)
        Return the normalized sinc function.

        The sinc function is equal to :math:`\sin(\pi x)/(\pi x)` for any argument
        :math:`x\ne 0`. ``sinc(0)`` takes the limit value 1, making ``sinc`` not
        only everywhere continuous but also infinitely differentiable.

        .. note::

            Note the normalization factor of ``pi`` used in the definition.
            This is the most commonly used definition in signal processing.
            Use ``sinc(x / np.pi)`` to obtain the unnormalized sinc function
            :math:`\sin(x)/x` that is more common in mathematics.

        Parameters
        ----------
        x : ndarray
            Array (possibly multi-dimensional) of values for which to calculate
            ``sinc(x)``.

        Returns
        -------
        out : ndarray
            ``sinc(x)``, which has the same shape as the input.

        Notes
        -----
        The name sinc is short for "sine cardinal" or "sinus cardinalis".

        The sinc function is used in various signal processing applications,
        including in anti-aliasing, in the construction of a Lanczos resampling
        filter, and in interpolation.

        For bandlimited interpolation of discrete-time signals, the ideal
        interpolation kernel is proportional to the sinc function.

        References
        ----------
        .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web
               Resource. https://mathworld.wolfram.com/SincFunction.html
        .. [2] Wikipedia, "Sinc function",
               https://en.wikipedia.org/wiki/Sinc_function

        Examples
        --------
        >>> import numpy as np
        >>> import matplotlib.pyplot as plt
        >>> x = np.linspace(-4, 4, 41)
        >>> np.sinc(x)
         array([-3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02, # may vary
                -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
                6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
                8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
                -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
                3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
                7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
                9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
                2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
               -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
               -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
                1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
                -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
                -4.92362781e-02,  -3.89804309e-17])

        >>> plt.plot(x, np.sinc(x))
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.title("Sinc Function")
        Text(0.5, 1.0, 'Sinc Function')
        >>> plt.ylabel("Amplitude")
        Text(0, 0.5, 'Amplitude')
        >>> plt.xlabel("X")
        Text(0.5, 0, 'X')
        >>> plt.show()

    size(a, axis=None)
        Return the number of elements along a given axis.

        Parameters
        ----------
        a : array_like
            Input data.
        axis : int, optional
            Axis along which the elements are counted.  By default, give
            the total number of elements.

        Returns
        -------
        element_count : int
            Number of elements along the specified axis.

        See Also
        --------
        shape : dimensions of array
        ndarray.shape : dimensions of array
        ndarray.size : number of elements in array

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1,2,3],[4,5,6]])
        >>> np.size(a)
        6
        >>> np.size(a,1)
        3
        >>> np.size(a,0)
        2

    sort(a, axis=-1, kind=None, order=None, *, stable=None)
        Return a sorted copy of an array.

        Parameters
        ----------
        a : array_like
            Array to be sorted.
        axis : int or None, optional
            Axis along which to sort. If None, the array is flattened before
            sorting. The default is -1, which sorts along the last axis.
        kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
            Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
            and 'mergesort' use timsort or radix sort under the covers and,
            in general, the actual implementation will vary with data type.
            The 'mergesort' option is retained for backwards compatibility.

            .. versionchanged:: 1.15.0.
               The 'stable' option was added.

        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.
        stable : bool, optional
            Sort stability. If ``True``, the returned array will maintain
            the relative order of ``a`` values which compare as equal.
            If ``False`` or ``None``, this is not guaranteed. Internally,
            this option selects ``kind='stable'``. Default: ``None``.

            .. versionadded:: 2.0.0

        Returns
        -------
        sorted_array : ndarray
            Array of the same type and shape as `a`.

        See Also
        --------
        ndarray.sort : Method to sort an array in-place.
        argsort : Indirect sort.
        lexsort : Indirect stable sort on multiple keys.
        searchsorted : Find elements in a sorted array.
        partition : Partial sort.

        Notes
        -----
        The various sorting algorithms are characterized by their average speed,
        worst case performance, work space size, and whether they are stable. A
        stable sort keeps items with the same key in the same relative
        order. The four algorithms implemented in NumPy have the following
        properties:

        =========== ======= ============= ============ ========
           kind      speed   worst case    work space   stable
        =========== ======= ============= ============ ========
        'quicksort'    1     O(n^2)            0          no
        'heapsort'     3     O(n*log(n))       0          no
        'mergesort'    2     O(n*log(n))      ~n/2        yes
        'timsort'      2     O(n*log(n))      ~n/2        yes
        =========== ======= ============= ============ ========

        .. note:: The datatype determines which of 'mergesort' or 'timsort'
           is actually used, even if 'mergesort' is specified. User selection
           at a finer scale is not currently available.

        For performance, ``sort`` makes a temporary copy if needed to make the data
        `contiguous <https://numpy.org/doc/stable/glossary.html#term-contiguous>`_
        in memory along the sort axis. For even better performance and reduced
        memory consumption, ensure that the array is already contiguous along the
        sort axis.

        The sort order for complex numbers is lexicographic. If both the real
        and imaginary parts are non-nan then the order is determined by the
        real parts except when they are equal, in which case the order is
        determined by the imaginary parts.

        Previous to numpy 1.4.0 sorting real and complex arrays containing nan
        values led to undefined behaviour. In numpy versions >= 1.4.0 nan
        values are sorted to the end. The extended sort order is:

          * Real: [R, nan]
          * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]

        where R is a non-nan real value. Complex values with the same nan
        placements are sorted according to the non-nan part if it exists.
        Non-nan values are sorted as before.

        .. versionadded:: 1.12.0

        quicksort has been changed to:
        `introsort <https://en.wikipedia.org/wiki/Introsort>`_.
        When sorting does not make enough progress it switches to
        `heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.
        This implementation makes quicksort O(n*log(n)) in the worst case.

        'stable' automatically chooses the best stable sorting algorithm
        for the data type being sorted.
        It, along with 'mergesort' is currently mapped to
        `timsort <https://en.wikipedia.org/wiki/Timsort>`_
        or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_
        depending on the data type.
        API forward compatibility currently limits the
        ability to select the implementation and it is hardwired for the different
        data types.

        .. versionadded:: 1.17.0

        Timsort is added for better performance on already or nearly
        sorted data. On random data timsort is almost identical to
        mergesort. It is now used for stable sort while quicksort is still the
        default sort if none is chosen. For timsort details, refer to
        `CPython listsort.txt
        <https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_
        'mergesort' and 'stable' are mapped to radix sort for integer data types.
        Radix sort is an O(n) sort instead of O(n log n).

        .. versionchanged:: 1.18.0

        NaT now sorts to the end of arrays for consistency with NaN.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1,4],[3,1]])
        >>> np.sort(a)                # sort along the last axis
        array([[1, 4],
               [1, 3]])
        >>> np.sort(a, axis=None)     # sort the flattened array
        array([1, 1, 3, 4])
        >>> np.sort(a, axis=0)        # sort along the first axis
        array([[1, 1],
               [3, 4]])

        Use the `order` keyword to specify a field to use when sorting a
        structured array:

        >>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
        >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
        ...           ('Galahad', 1.7, 38)]
        >>> a = np.array(values, dtype=dtype)       # create a structured array
        >>> np.sort(a, order='height')                        # doctest: +SKIP
        array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
               ('Lancelot', 1.8999999999999999, 38)],
              dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

        Sort by age, then height if ages are equal:

        >>> np.sort(a, order=['age', 'height'])               # doctest: +SKIP
        array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
               ('Arthur', 1.8, 41)],
              dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

    sort_complex(a)
        Sort a complex array using the real part first, then the imaginary part.

        Parameters
        ----------
        a : array_like
            Input array

        Returns
        -------
        out : complex ndarray
            Always returns a sorted complex array.

        Examples
        --------
        >>> import numpy as np
        >>> np.sort_complex([5, 3, 6, 2, 1])
        array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])

        >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
        array([1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])

    split(ary, indices_or_sections, axis=0)
        Split an array into multiple sub-arrays as views into `ary`.

        Parameters
        ----------
        ary : ndarray
            Array to be divided into sub-arrays.
        indices_or_sections : int or 1-D array
            If `indices_or_sections` is an integer, N, the array will be divided
            into N equal arrays along `axis`.  If such a split is not possible,
            an error is raised.

            If `indices_or_sections` is a 1-D array of sorted integers, the entries
            indicate where along `axis` the array is split.  For example,
            ``[2, 3]`` would, for ``axis=0``, result in

            - ary[:2]
            - ary[2:3]
            - ary[3:]

            If an index exceeds the dimension of the array along `axis`,
            an empty sub-array is returned correspondingly.
        axis : int, optional
            The axis along which to split, default is 0.

        Returns
        -------
        sub-arrays : list of ndarrays
            A list of sub-arrays as views into `ary`.

        Raises
        ------
        ValueError
            If `indices_or_sections` is given as an integer, but
            a split does not result in equal division.

        See Also
        --------
        array_split : Split an array into multiple sub-arrays of equal or
                      near-equal size.  Does not raise an exception if
                      an equal division cannot be made.
        hsplit : Split array into multiple sub-arrays horizontally (column-wise).
        vsplit : Split array into multiple sub-arrays vertically (row wise).
        dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
        concatenate : Join a sequence of arrays along an existing axis.
        stack : Join a sequence of arrays along a new axis.
        hstack : Stack arrays in sequence horizontally (column wise).
        vstack : Stack arrays in sequence vertically (row wise).
        dstack : Stack arrays in sequence depth wise (along third dimension).

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(9.0)
        >>> np.split(x, 3)
        [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]

        >>> x = np.arange(8.0)
        >>> np.split(x, [3, 5, 6, 10])
        [array([0.,  1.,  2.]),
         array([3.,  4.]),
         array([5.]),
         array([6.,  7.]),
         array([], dtype=float64)]

    squeeze(a, axis=None)
        Remove axes of length one from `a`.

        Parameters
        ----------
        a : array_like
            Input data.
        axis : None or int or tuple of ints, optional
            .. versionadded:: 1.7.0

            Selects a subset of the entries of length one in the
            shape. If an axis is selected with shape entry greater than
            one, an error is raised.

        Returns
        -------
        squeezed : ndarray
            The input array, but with all or a subset of the
            dimensions of length 1 removed. This is always `a` itself
            or a view into `a`. Note that if all axes are squeezed,
            the result is a 0d array and not a scalar.

        Raises
        ------
        ValueError
            If `axis` is not None, and an axis being squeezed is not of length 1

        See Also
        --------
        expand_dims : The inverse operation, adding entries of length one
        reshape : Insert, remove, and combine dimensions, and resize existing ones

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([[[0], [1], [2]]])
        >>> x.shape
        (1, 3, 1)
        >>> np.squeeze(x).shape
        (3,)
        >>> np.squeeze(x, axis=0).shape
        (3, 1)
        >>> np.squeeze(x, axis=1).shape
        Traceback (most recent call last):
        ...
        ValueError: cannot select an axis to squeeze out which has size
        not equal to one
        >>> np.squeeze(x, axis=2).shape
        (1, 3)
        >>> x = np.array([[1234]])
        >>> x.shape
        (1, 1)
        >>> np.squeeze(x)
        array(1234)  # 0d array
        >>> np.squeeze(x).shape
        ()
        >>> np.squeeze(x)[()]
        1234

    stack(arrays, axis=0, out=None, *, dtype=None, casting='same_kind')
        Join a sequence of arrays along a new axis.

        The ``axis`` parameter specifies the index of the new axis in the
        dimensions of the result. For example, if ``axis=0`` it will be the first
        dimension and if ``axis=-1`` it will be the last dimension.

        .. versionadded:: 1.10.0

        Parameters
        ----------
        arrays : sequence of array_like
            Each array must have the same shape.

        axis : int, optional
            The axis in the result array along which the input arrays are stacked.

        out : ndarray, optional
            If provided, the destination to place the result. The shape must be
            correct, matching that of what stack would have returned if no
            out argument were specified.

        dtype : str or dtype
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`.

            .. versionadded:: 1.24

        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur. Defaults to 'same_kind'.

            .. versionadded:: 1.24


        Returns
        -------
        stacked : ndarray
            The stacked array has one more dimension than the input arrays.

        See Also
        --------
        concatenate : Join a sequence of arrays along an existing axis.
        block : Assemble an nd-array from nested lists of blocks.
        split : Split array into a list of multiple sub-arrays of equal size.
        unstack : Split an array into a tuple of sub-arrays along an axis.

        Examples
        --------
        >>> import numpy as np
        >>> rng = np.random.default_rng()
        >>> arrays = [rng.normal(size=(3,4)) for _ in range(10)]
        >>> np.stack(arrays, axis=0).shape
        (10, 3, 4)

        >>> np.stack(arrays, axis=1).shape
        (3, 10, 4)

        >>> np.stack(arrays, axis=2).shape
        (3, 4, 10)

        >>> a = np.array([1, 2, 3])
        >>> b = np.array([4, 5, 6])
        >>> np.stack((a, b))
        array([[1, 2, 3],
               [4, 5, 6]])

        >>> np.stack((a, b), axis=-1)
        array([[1, 4],
               [2, 5],
               [3, 6]])

    std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>, mean=<no value>, correction=<no value>)
        Compute the standard deviation along the specified axis.

        Returns the standard deviation, a measure of the spread of a distribution,
        of the array elements. The standard deviation is computed for the
        flattened array by default, otherwise over the specified axis.

        Parameters
        ----------
        a : array_like
            Calculate the standard deviation of these values.
        axis : None or int or tuple of ints, optional
            Axis or axes along which the standard deviation is computed. The
            default is to compute the standard deviation of the flattened array.

            .. versionadded:: 1.7.0

            If this is a tuple of ints, a standard deviation is performed over
            multiple axes, instead of a single axis or all the axes as before.
        dtype : dtype, optional
            Type to use in computing the standard deviation. For arrays of
            integer type the default is float64, for arrays of float types it is
            the same as the array type.
        out : ndarray, optional
            Alternative output array in which to place the result. It must have
            the same shape as the expected output but the type (of the calculated
            values) will be cast if necessary.
            See :ref:`ufuncs-output-type` for more details.
        ddof : {int, float}, optional
            Means Delta Degrees of Freedom.  The divisor used in calculations
            is ``N - ddof``, where ``N`` represents the number of elements.
            By default `ddof` is zero. See Notes for details about use of `ddof`.
        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 `std` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.
        where : array_like of bool, optional
            Elements to include in the standard deviation.
            See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.20.0

        mean : array_like, optional
            Provide the mean to prevent its recalculation. The mean should have
            a shape as if it was calculated with ``keepdims=True``.
            The axis for the calculation of the mean should be the same as used in
            the call to this std function.

            .. versionadded:: 1.26.0

        correction : {int, float}, optional
            Array API compatible name for the ``ddof`` parameter. Only one of them
            can be provided at the same time.

            .. versionadded:: 2.0.0

        Returns
        -------
        standard_deviation : ndarray, see dtype parameter above.
            If `out` is None, return a new array containing the standard deviation,
            otherwise return a reference to the output array.

        See Also
        --------
        var, mean, nanmean, nanstd, nanvar
        :ref:`ufuncs-output-type`

        Notes
        -----
        There are several common variants of the array standard deviation
        calculation. Assuming the input `a` is a one-dimensional NumPy array
        and ``mean`` is either provided as an argument or computed as
        ``a.mean()``, NumPy computes the standard deviation of an array as::

            N = len(a)
            d2 = abs(a - mean)**2  # abs is for complex `a`
            var = d2.sum() / (N - ddof)  # note use of `ddof`
            std = var**0.5

        Different values of the argument `ddof` are useful in different
        contexts. NumPy's default ``ddof=0`` corresponds with the expression:

        .. math::

            \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N}}

        which is sometimes called the "population standard deviation" in the field
        of statistics because it applies the definition of standard deviation to
        `a` as if `a` were a complete population of possible observations.

        Many other libraries define the standard deviation of an array
        differently, e.g.:

        .. math::

            \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N - 1}}

        In statistics, the resulting quantity is sometimed called the "sample
        standard deviation" because if `a` is a random sample from a larger
        population, this calculation provides the square root of an unbiased
        estimate of the variance of the population. The use of :math:`N-1` in the
        denominator is often called "Bessel's correction" because it corrects for
        bias (toward lower values) in the variance estimate introduced when the
        sample mean of `a` is used in place of the true mean of the population.
        The resulting estimate of the standard deviation is still biased, but less
        than it would have been without the correction. For this quantity, use
        ``ddof=1``.

        Note that, for complex numbers, `std` takes the absolute
        value before squaring, so that the result is always real and nonnegative.

        For floating-point input, the standard deviation is computed using the same
        precision the input has. Depending on the input data, this can cause
        the results to be inaccurate, especially for float32 (see example below).
        Specifying a higher-accuracy accumulator using the `dtype` keyword can
        alleviate this issue.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> np.std(a)
        1.1180339887498949 # may vary
        >>> np.std(a, axis=0)
        array([1.,  1.])
        >>> np.std(a, axis=1)
        array([0.5,  0.5])

        In single precision, std() can be inaccurate:

        >>> a = np.zeros((2, 512*512), dtype=np.float32)
        >>> a[0, :] = 1.0
        >>> a[1, :] = 0.1
        >>> np.std(a)
        0.45000005

        Computing the standard deviation in float64 is more accurate:

        >>> np.std(a, dtype=np.float64)
        0.44999999925494177 # may vary

        Specifying a where argument:

        >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
        >>> np.std(a)
        2.614064523559687 # may vary
        >>> np.std(a, where=[[True], [True], [False]])
        2.0

        Using the mean keyword to save computation time:

        >>> import numpy as np
        >>> from timeit import timeit
        >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
        >>> mean = np.mean(a, axis=1, keepdims=True)
        >>>
        >>> g = globals()
        >>> n = 10000
        >>> t1 = timeit("std = np.std(a, axis=1, mean=mean)", globals=g, number=n)
        >>> t2 = timeit("std = np.std(a, axis=1)", globals=g, number=n)
        >>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%')
        #doctest: +SKIP
        Percentage execution time saved 30%

    sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
        Sum of array elements over a given axis.

        Parameters
        ----------
        a : array_like
            Elements to sum.
        axis : None or int or tuple of ints, optional
            Axis or axes along which a sum is performed.  The default,
            axis=None, will sum all of the elements of the input array.  If
            axis is negative it counts from the last to the first axis.

            .. versionadded:: 1.7.0

            If axis is a tuple of ints, a sum is performed on all of the axes
            specified in the tuple instead of a single axis or all the axes as
            before.
        dtype : dtype, optional
            The type of the returned array 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.
        out : ndarray, optional
            Alternative output array 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.
        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 `sum` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.
        initial : scalar, optional
            Starting value for the sum. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.15.0

        where : array_like of bool, optional
            Elements to include in the sum. See `~numpy.ufunc.reduce` for details.

            .. versionadded:: 1.17.0

        Returns
        -------
        sum_along_axis : ndarray
            An array with the same shape as `a`, with the specified
            axis removed.   If `a` is a 0-d array, or if `axis` is None, a scalar
            is returned.  If an output array is specified, a reference to
            `out` is returned.

        See Also
        --------
        ndarray.sum : Equivalent method.
        add: ``numpy.add.reduce`` equivalent function.
        cumsum : Cumulative sum of array elements.
        trapezoid : Integration of array values using composite trapezoidal rule.

        mean, average

        Notes
        -----
        Arithmetic is modular when using integer types, and no error is
        raised on overflow.

        The sum of an empty array is the neutral element 0:

        >>> np.sum([])
        0.0

        For floating point numbers the numerical precision of sum (and
        ``np.add.reduce``) is in general limited by directly adding each number
        individually to the result causing rounding errors in every step.
        However, often numpy will use a  numerically better approach (partial
        pairwise summation) leading to improved precision in many use-cases.
        This improved precision is always provided when no ``axis`` is given.
        When ``axis`` is given, it will depend on which axis is summed.
        Technically, to provide the best speed possible, the improved precision
        is only used when the summation is along the fast axis in memory.
        Note that the exact precision may vary depending on other parameters.
        In contrast to NumPy, Python's ``math.fsum`` function uses a slower but
        more precise approach to summation.
        Especially when summing a large number of lower precision floating point
        numbers, such as ``float32``, numerical errors can become significant.
        In such cases it can be advisable to use `dtype="float64"` to use a higher
        precision for the output.

        Examples
        --------
        >>> import numpy as np
        >>> np.sum([0.5, 1.5])
        2.0
        >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
        1
        >>> np.sum([[0, 1], [0, 5]])
        6
        >>> np.sum([[0, 1], [0, 5]], axis=0)
        array([0, 6])
        >>> np.sum([[0, 1], [0, 5]], axis=1)
        array([1, 5])
        >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
        array([1., 5.])

        If the accumulator is too small, overflow occurs:

        >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)
        -128

        You can also start the sum with a value other than zero:

        >>> np.sum([10], initial=5)
        15

    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
        --------
        >>> import numpy as np
        >>> 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]]])

    take(a, indices, axis=None, out=None, mode='raise')
        Take elements from an array along an axis.

        When axis is not None, this function does the same thing as "fancy"
        indexing (indexing arrays using arrays); however, it can be easier to use
        if you need elements along a given axis. A call such as
        ``np.take(arr, indices, axis=3)`` is equivalent to
        ``arr[:,:,:,indices,...]``.

        Explained without fancy indexing, this is equivalent to the following use
        of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of
        indices::

            Ni, Nk = a.shape[:axis], a.shape[axis+1:]
            Nj = indices.shape
            for ii in ndindex(Ni):
                for jj in ndindex(Nj):
                    for kk in ndindex(Nk):
                        out[ii + jj + kk] = a[ii + (indices[jj],) + kk]

        Parameters
        ----------
        a : array_like (Ni..., M, Nk...)
            The source array.
        indices : array_like (Nj...)
            The indices of the values to extract.

            .. versionadded:: 1.8.0

            Also allow scalars for indices.
        axis : int, optional
            The axis over which to select values. By default, the flattened
            input array is used.
        out : ndarray, optional (Ni..., Nj..., Nk...)
            If provided, the result will be placed in this array. It should
            be of the appropriate shape and dtype. Note that `out` is always
            buffered if `mode='raise'`; use other modes for better performance.
        mode : {'raise', 'wrap', 'clip'}, optional
            Specifies how out-of-bounds indices will behave.

            * 'raise' -- raise an error (default)
            * 'wrap' -- wrap around
            * 'clip' -- clip to the range

            'clip' mode means that all indices that are too large are replaced
            by the index that addresses the last element along that axis. Note
            that this disables indexing with negative numbers.

        Returns
        -------
        out : ndarray (Ni..., Nj..., Nk...)
            The returned array has the same type as `a`.

        See Also
        --------
        compress : Take elements using a boolean mask
        ndarray.take : equivalent method
        take_along_axis : Take elements by matching the array and the index arrays

        Notes
        -----

        By eliminating the inner loop in the description above, and using `s_` to
        build simple slice objects, `take` can be expressed  in terms of applying
        fancy indexing to each 1-d slice::

            Ni, Nk = a.shape[:axis], a.shape[axis+1:]
            for ii in ndindex(Ni):
                for kk in ndindex(Nj):
                    out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]

        For this reason, it is equivalent to (but faster than) the following use
        of `apply_along_axis`::

            out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)

        Examples
        --------
        >>> import numpy as np
        >>> a = [4, 3, 5, 7, 6, 8]
        >>> indices = [0, 1, 4]
        >>> np.take(a, indices)
        array([4, 3, 6])

        In this example if `a` is an ndarray, "fancy" indexing can be used.

        >>> a = np.array(a)
        >>> a[indices]
        array([4, 3, 6])

        If `indices` is not one dimensional, the output also has these dimensions.

        >>> np.take(a, [[0, 1], [2, 3]])
        array([[4, 3],
               [5, 7]])

    take_along_axis(arr, indices, axis)
        Take values from the input array by matching 1d index and data slices.

        This iterates over matching 1d slices oriented along the specified axis in
        the index and data arrays, and uses the former to look up values in the
        latter. These slices can be different lengths.

        Functions returning an index along an axis, like `argsort` and
        `argpartition`, produce suitable indices for this function.

        .. versionadded:: 1.15.0

        Parameters
        ----------
        arr : ndarray (Ni..., M, Nk...)
            Source array
        indices : ndarray (Ni..., J, Nk...)
            Indices to take along each 1d slice of `arr`. This must match the
            dimension of arr, but dimensions Ni and Nj only need to broadcast
            against `arr`.
        axis : int
            The axis to take 1d slices along. If axis is None, the input array is
            treated as if it had first been flattened to 1d, for consistency with
            `sort` and `argsort`.

        Returns
        -------
        out: ndarray (Ni..., J, Nk...)
            The indexed result.

        Notes
        -----
        This is equivalent to (but faster than) the following use of `ndindex` and
        `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::

            Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
            J = indices.shape[axis]  # Need not equal M
            out = np.empty(Ni + (J,) + Nk)

            for ii in ndindex(Ni):
                for kk in ndindex(Nk):
                    a_1d       = a      [ii + s_[:,] + kk]
                    indices_1d = indices[ii + s_[:,] + kk]
                    out_1d     = out    [ii + s_[:,] + kk]
                    for j in range(J):
                        out_1d[j] = a_1d[indices_1d[j]]

        Equivalently, eliminating the inner loop, the last two lines would be::

                    out_1d[:] = a_1d[indices_1d]

        See Also
        --------
        take : Take along an axis, using the same indices for every 1d slice
        put_along_axis :
            Put values into the destination array by matching 1d index and data slices

        Examples
        --------
        >>> import numpy as np

        For this sample array

        >>> a = np.array([[10, 30, 20], [60, 40, 50]])

        We can sort either by using sort directly, or argsort and this function

        >>> np.sort(a, axis=1)
        array([[10, 20, 30],
               [40, 50, 60]])
        >>> ai = np.argsort(a, axis=1)
        >>> ai
        array([[0, 2, 1],
               [1, 2, 0]])
        >>> np.take_along_axis(a, ai, axis=1)
        array([[10, 20, 30],
               [40, 50, 60]])

        The same works for max and min, if you maintain the trivial dimension
        with ``keepdims``:

        >>> np.max(a, axis=1, keepdims=True)
        array([[30],
               [60]])
        >>> ai = np.argmax(a, axis=1, keepdims=True)
        >>> ai
        array([[1],
               [0]])
        >>> np.take_along_axis(a, ai, axis=1)
        array([[30],
               [60]])

        If we want to get the max and min at the same time, we can stack the
        indices first

        >>> ai_min = np.argmin(a, axis=1, keepdims=True)
        >>> ai_max = np.argmax(a, axis=1, keepdims=True)
        >>> ai = np.concatenate([ai_min, ai_max], axis=1)
        >>> ai
        array([[0, 1],
               [1, 0]])
        >>> np.take_along_axis(a, ai, axis=1)
        array([[10, 30],
               [40, 60]])

    tensordot(a, b, axes=2)
        Compute tensor dot product along specified axes.

        Given two tensors, `a` and `b`, and an array_like object containing
        two array_like objects, ``(a_axes, b_axes)``, sum the products of
        `a`'s and `b`'s elements (components) over the axes specified by
        ``a_axes`` and ``b_axes``. The third argument can be a single non-negative
        integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
        of `a` and the first ``N`` dimensions of `b` are summed over.

        Parameters
        ----------
        a, b : array_like
            Tensors to "dot".

        axes : int or (2,) array_like
            * integer_like
              If an int N, sum over the last N axes of `a` and the first N axes
              of `b` in order. The sizes of the corresponding axes must match.
            * (2,) array_like
              Or, a list of axes to be summed over, first sequence applying to `a`,
              second to `b`. Both elements array_like must be of the same length.

        Returns
        -------
        output : ndarray
            The tensor dot product of the input.

        See Also
        --------
        dot, einsum

        Notes
        -----
        Three common use cases are:

        * ``axes = 0`` : tensor product :math:`a\otimes b`
        * ``axes = 1`` : tensor dot product :math:`a\cdot b`
        * ``axes = 2`` : (default) tensor double contraction :math:`a:b`

        When `axes` is a positive integer ``N``, the operation starts with
        axis ``-N`` of `a` and axis ``0`` of `b`, and it continues through
        axis ``-1`` of `a` and axis ``N-1`` of `b` (inclusive).

        When there is more than one axis to sum over - and they are not the last
        (first) axes of `a` (`b`) - the argument `axes` should consist of
        two sequences of the same length, with the first axis to sum over given
        first in both sequences, the second axis second, and so forth.

        The shape of the result consists of the non-contracted axes of the
        first tensor, followed by the non-contracted axes of the second.

        Examples
        --------
        A "traditional" example:

        >>> import numpy as np
        >>> a = np.arange(60.).reshape(3,4,5)
        >>> b = np.arange(24.).reshape(4,3,2)
        >>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
        >>> c.shape
        (5, 2)
        >>> c
        array([[4400., 4730.],
               [4532., 4874.],
               [4664., 5018.],
               [4796., 5162.],
               [4928., 5306.]])
        >>> # A slower but equivalent way of computing the same...
        >>> d = np.zeros((5,2))
        >>> for i in range(5):
        ...   for j in range(2):
        ...     for k in range(3):
        ...       for n in range(4):
        ...         d[i,j] += a[k,n,i] * b[n,k,j]
        >>> c == d
        array([[ True,  True],
               [ True,  True],
               [ True,  True],
               [ True,  True],
               [ True,  True]])

        An extended example taking advantage of the overloading of + and \*:

        >>> a = np.array(range(1, 9))
        >>> a.shape = (2, 2, 2)
        >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
        >>> A.shape = (2, 2)
        >>> a; A
        array([[[1, 2],
                [3, 4]],
               [[5, 6],
                [7, 8]]])
        array([['a', 'b'],
               ['c', 'd']], dtype=object)

        >>> np.tensordot(a, A) # third argument default is 2 for double-contraction
        array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)

        >>> np.tensordot(a, A, 1)
        array([[['acc', 'bdd'],
                ['aaacccc', 'bbbdddd']],
               [['aaaaacccccc', 'bbbbbdddddd'],
                ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)

        >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
        array([[[[['a', 'b'],
                  ['c', 'd']],
                  ...

        >>> np.tensordot(a, A, (0, 1))
        array([[['abbbbb', 'cddddd'],
                ['aabbbbbb', 'ccdddddd']],
               [['aaabbbbbbb', 'cccddddddd'],
                ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)

        >>> np.tensordot(a, A, (2, 1))
        array([[['abb', 'cdd'],
                ['aaabbbb', 'cccdddd']],
               [['aaaaabbbbbb', 'cccccdddddd'],
                ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)

        >>> np.tensordot(a, A, ((0, 1), (0, 1)))
        array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)

        >>> np.tensordot(a, A, ((2, 1), (1, 0)))
        array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)

    tile(A, reps)
        Construct an array by repeating A the number of times given by reps.

        If `reps` has length ``d``, the result will have dimension of
        ``max(d, A.ndim)``.

        If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
        axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
        or shape (1, 1, 3) for 3-D replication. If this is not the desired
        behavior, promote `A` to d-dimensions manually before calling this
        function.

        If ``A.ndim > d``, `reps` is promoted to `A`.ndim by prepending 1's to it.
        Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
        (1, 1, 2, 2).

        Note : Although tile may be used for broadcasting, it is strongly
        recommended to use numpy's broadcasting operations and functions.

        Parameters
        ----------
        A : array_like
            The input array.
        reps : array_like
            The number of repetitions of `A` along each axis.

        Returns
        -------
        c : ndarray
            The tiled output array.

        See Also
        --------
        repeat : Repeat elements of an array.
        broadcast_to : Broadcast an array to a new shape

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([0, 1, 2])
        >>> np.tile(a, 2)
        array([0, 1, 2, 0, 1, 2])
        >>> np.tile(a, (2, 2))
        array([[0, 1, 2, 0, 1, 2],
               [0, 1, 2, 0, 1, 2]])
        >>> np.tile(a, (2, 1, 2))
        array([[[0, 1, 2, 0, 1, 2]],
               [[0, 1, 2, 0, 1, 2]]])

        >>> b = np.array([[1, 2], [3, 4]])
        >>> np.tile(b, 2)
        array([[1, 2, 1, 2],
               [3, 4, 3, 4]])
        >>> np.tile(b, (2, 1))
        array([[1, 2],
               [3, 4],
               [1, 2],
               [3, 4]])

        >>> c = np.array([1,2,3,4])
        >>> np.tile(c,(4,1))
        array([[1, 2, 3, 4],
               [1, 2, 3, 4],
               [1, 2, 3, 4],
               [1, 2, 3, 4]])

    trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)
        Return the sum along diagonals of the array.

        If `a` is 2-D, the sum along its diagonal with the given offset
        is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.

        If `a` has more than two dimensions, then the axes specified by axis1 and
        axis2 are used to determine the 2-D sub-arrays whose traces are returned.
        The shape of the resulting array is the same as that of `a` with `axis1`
        and `axis2` removed.

        Parameters
        ----------
        a : array_like
            Input array, from which the diagonals are taken.
        offset : int, optional
            Offset of the diagonal from the main diagonal. Can be both positive
            and negative. Defaults to 0.
        axis1, axis2 : int, optional
            Axes to be used as the first and second axis of the 2-D sub-arrays
            from which the diagonals should be taken. Defaults are the first two
            axes of `a`.
        dtype : dtype, optional
            Determines the data-type of the returned array and of the accumulator
            where the elements are summed. If dtype has the value None and `a` is
            of integer type of precision less than the default integer
            precision, then the default integer precision is used. Otherwise,
            the precision is the same as that of `a`.
        out : ndarray, optional
            Array into which the output is placed. Its type is preserved and
            it must be of the right shape to hold the output.

        Returns
        -------
        sum_along_diagonals : ndarray
            If `a` is 2-D, the sum along the diagonal is returned.  If `a` has
            larger dimensions, then an array of sums along diagonals is returned.

        See Also
        --------
        diag, diagonal, diagflat

        Examples
        --------
        >>> import numpy as np
        >>> np.trace(np.eye(3))
        3.0
        >>> a = np.arange(8).reshape((2,2,2))
        >>> np.trace(a)
        array([6, 8])

        >>> a = np.arange(24).reshape((2,2,2,3))
        >>> np.trace(a).shape
        (2, 3)

    transpose(a, axes=None)
        Returns an array with axes transposed.

        For a 1-D array, this returns an unchanged view of the original array, as a
        transposed vector is simply the same vector.
        To convert a 1-D array into a 2-D column vector, an additional dimension
        must be added, e.g., ``np.atleast_2d(a).T`` achieves this, as does
        ``a[:, np.newaxis]``.
        For a 2-D array, this is the standard 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, then
        ``transpose(a).shape == a.shape[::-1]``.

        Parameters
        ----------
        a : array_like
            Input array.
        axes : tuple or list of ints, optional
            If specified, it must be a tuple or list which contains a permutation
            of [0,1,...,N-1] where N is the number of axes of `a`. The `i`'th axis
            of the returned array will correspond to the axis numbered ``axes[i]``
            of the input. If not specified, defaults to ``range(a.ndim)[::-1]``,
            which reverses the order of the axes.

        Returns
        -------
        p : ndarray
            `a` with its axes permuted. A view is returned whenever possible.

        See Also
        --------
        ndarray.transpose : Equivalent method.
        moveaxis : Move axes of an array to new positions.
        argsort : Return the indices that would sort an array.

        Notes
        -----
        Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors
        when using the `axes` keyword argument.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> a
        array([[1, 2],
               [3, 4]])
        >>> np.transpose(a)
        array([[1, 3],
               [2, 4]])

        >>> a = np.array([1, 2, 3, 4])
        >>> a
        array([1, 2, 3, 4])
        >>> np.transpose(a)
        array([1, 2, 3, 4])

        >>> a = np.ones((1, 2, 3))
        >>> np.transpose(a, (1, 0, 2)).shape
        (2, 1, 3)

        >>> a = np.ones((2, 3, 4, 5))
        >>> np.transpose(a).shape
        (5, 4, 3, 2)

    trapezoid(y, x=None, dx=1.0, axis=-1)
        Integrate along the given axis using the composite trapezoidal rule.

        If `x` is provided, the integration happens in sequence along its
        elements - they are not sorted.

        Integrate `y` (`x`) along each 1d slice on the given axis, compute
        :math:`\int y(x) dx`.
        When `x` is specified, this integrates along the parametric curve,
        computing :math:`\int_t y(t) dt =
        \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`.

        .. versionadded:: 2.0.0

        Parameters
        ----------
        y : array_like
            Input array to integrate.
        x : array_like, optional
            The sample points corresponding to the `y` values. If `x` is None,
            the sample points are assumed to be evenly spaced `dx` apart. The
            default is None.
        dx : scalar, optional
            The spacing between sample points when `x` is None. The default is 1.
        axis : int, optional
            The axis along which to integrate.

        Returns
        -------
        trapezoid : float or ndarray
            Definite integral of `y` = n-dimensional array as approximated along
            a single axis by the trapezoidal rule. If `y` is a 1-dimensional array,
            then the result is a float. If `n` is greater than 1, then the result
            is an `n`-1 dimensional array.

        See Also
        --------
        sum, cumsum

        Notes
        -----
        Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
        will be taken from `y` array, by default x-axis distances between
        points will be 1.0, alternatively they can be provided with `x` array
        or with `dx` scalar.  Return value will be equal to combined area under
        the red lines.


        References
        ----------
        .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule

        .. [2] Illustration image:
               https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png

        Examples
        --------
        >>> import numpy as np

        Use the trapezoidal rule on evenly spaced points:

        >>> np.trapezoid([1, 2, 3])
        4.0

        The spacing between sample points can be selected by either the
        ``x`` or ``dx`` arguments:

        >>> np.trapezoid([1, 2, 3], x=[4, 6, 8])
        8.0
        >>> np.trapezoid([1, 2, 3], dx=2)
        8.0

        Using a decreasing ``x`` corresponds to integrating in reverse:

        >>> np.trapezoid([1, 2, 3], x=[8, 6, 4])
        -8.0

        More generally ``x`` is used to integrate along a parametric curve. We can
        estimate the integral :math:`\int_0^1 x^2 = 1/3` using:

        >>> x = np.linspace(0, 1, num=50)
        >>> y = x**2
        >>> np.trapezoid(y, x)
        0.33340274885464394

        Or estimate the area of a circle, noting we repeat the sample which closes
        the curve:

        >>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)
        >>> np.trapezoid(np.cos(theta), x=np.sin(theta))
        3.141571941375841

        ``np.trapezoid`` can be applied along a specified axis to do multiple
        computations in one call:

        >>> a = np.arange(6).reshape(2, 3)
        >>> a
        array([[0, 1, 2],
               [3, 4, 5]])
        >>> np.trapezoid(a, axis=0)
        array([1.5, 2.5, 3.5])
        >>> np.trapezoid(a, axis=1)
        array([2.,  8.])

    trapz(y, x=None, dx=1.0, axis=-1)
        `trapz` is deprecated in NumPy 2.0.

        Please use `trapezoid` instead, or one of the numerical integration
        functions in `scipy.integrate`.

    tri(N, M=None, k=0, dtype=<class 'float'>, *, like=None)
        An array with ones at and below the given diagonal and zeros elsewhere.

        Parameters
        ----------
        N : int
            Number of rows in the array.
        M : int, optional
            Number of columns in the array.
            By default, `M` is taken equal to `N`.
        k : int, optional
            The sub-diagonal at and below which the array is filled.
            `k` = 0 is the main diagonal, while `k` < 0 is below it,
            and `k` > 0 is above.  The default is 0.
        dtype : dtype, optional
            Data type of the returned array.  The default is float.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        tri : ndarray of shape (N, M)
            Array with its lower triangle filled with ones and zero elsewhere;
            in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.

        Examples
        --------
        >>> import numpy as np
        >>> np.tri(3, 5, 2, dtype=int)
        array([[1, 1, 1, 0, 0],
               [1, 1, 1, 1, 0],
               [1, 1, 1, 1, 1]])

        >>> np.tri(3, 5, -1)
        array([[0.,  0.,  0.,  0.,  0.],
               [1.,  0.,  0.,  0.,  0.],
               [1.,  1.,  0.,  0.,  0.]])

    tril(m, k=0)
        Lower triangle of an array.

        Return a copy of an array with elements above the `k`-th diagonal zeroed.
        For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two
        axes.

        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
        --------
        >>> import numpy as np
        >>> 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]])

        >>> np.tril(np.arange(3*4*5).reshape(3, 4, 5))
        array([[[ 0,  0,  0,  0,  0],
                [ 5,  6,  0,  0,  0],
                [10, 11, 12,  0,  0],
                [15, 16, 17, 18,  0]],
               [[20,  0,  0,  0,  0],
                [25, 26,  0,  0,  0],
                [30, 31, 32,  0,  0],
                [35, 36, 37, 38,  0]],
               [[40,  0,  0,  0,  0],
                [45, 46,  0,  0,  0],
                [50, 51, 52,  0,  0],
                [55, 56, 57, 58,  0]]])

    tril_indices(n, k=0, m=None)
        Return the indices for the lower-triangle of an (n, m) array.

        Parameters
        ----------
        n : int
            The row dimension of the arrays for which the returned
            indices will be valid.
        k : int, optional
            Diagonal offset (see `tril` for details).
        m : int, optional
            .. versionadded:: 1.9.0

            The column dimension of the arrays for which the returned
            arrays will be valid.
            By default `m` is taken equal to `n`.


        Returns
        -------
        inds : tuple of arrays
            The indices for the triangle. The returned tuple contains two arrays,
            each with the indices along one dimension of the array.

        See also
        --------
        triu_indices : similar function, for upper-triangular.
        mask_indices : generic function accepting an arbitrary mask function.
        tril, triu

        Notes
        -----
        .. versionadded:: 1.4.0

        Examples
        --------
        >>> import numpy as np

        Compute two different sets of indices to access 4x4 arrays, one for the
        lower triangular part starting at the main diagonal, and one starting two
        diagonals further right:

        >>> il1 = np.tril_indices(4)
        >>> il2 = np.tril_indices(4, 2)

        Here is how they can be used with a sample array:

        >>> a = np.arange(16).reshape(4, 4)
        >>> a
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15]])

        Both for indexing:

        >>> a[il1]
        array([ 0,  4,  5, ..., 13, 14, 15])

        And for assigning values:

        >>> a[il1] = -1
        >>> a
        array([[-1,  1,  2,  3],
               [-1, -1,  6,  7],
               [-1, -1, -1, 11],
               [-1, -1, -1, -1]])

        These cover almost the whole array (two diagonals right of the main one):

        >>> a[il2] = -10
        >>> a
        array([[-10, -10, -10,   3],
               [-10, -10, -10, -10],
               [-10, -10, -10, -10],
               [-10, -10, -10, -10]])

    tril_indices_from(arr, k=0)
        Return the indices for the lower-triangle of arr.

        See `tril_indices` for full details.

        Parameters
        ----------
        arr : array_like
            The indices will be valid for square arrays whose dimensions are
            the same as arr.
        k : int, optional
            Diagonal offset (see `tril` for details).

        Examples
        --------
        >>> import numpy as np

        Create a 4 by 4 array

        >>> a = np.arange(16).reshape(4, 4)
        >>> a
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15]])

        Pass the array to get the indices of the lower triangular elements.

        >>> trili = np.tril_indices_from(a)
        >>> trili
        (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3]))

        >>> a[trili]
        array([ 0,  4,  5,  8,  9, 10, 12, 13, 14, 15])

        This is syntactic sugar for tril_indices().

        >>> np.tril_indices(a.shape[0])
        (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3]))

        Use the `k` parameter to return the indices for the lower triangular array
        up to the k-th diagonal.

        >>> trili1 = np.tril_indices_from(a, k=1)
        >>> a[trili1]
        array([ 0,  1,  4,  5,  6,  8,  9, 10, 11, 12, 13, 14, 15])

        See Also
        --------
        tril_indices, tril, triu_indices_from

        Notes
        -----
        .. versionadded:: 1.4.0

    trim_zeros(filt, trim='fb')
        Trim the leading and/or trailing zeros from a 1-D array or sequence.

        Parameters
        ----------
        filt : 1-D array or sequence
            Input array.
        trim : str, optional
            A string with 'f' representing trim from front and 'b' to trim from
            back. Default is 'fb', trim zeros from both front and back of the
            array.

        Returns
        -------
        trimmed : 1-D array or sequence
            The result of trimming the input. The input data type is preserved.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
        >>> np.trim_zeros(a)
        array([1, 2, 3, 0, 2, 1])

        >>> np.trim_zeros(a, 'b')
        array([0, 0, 0, ..., 0, 2, 1])

        The input data type is preserved, list/tuple in means list/tuple out.

        >>> np.trim_zeros([0, 1, 2, 0])
        [1, 2]

    triu(m, k=0)
        Upper triangle of an array.

        Return a copy of an array with the elements below the `k`-th diagonal
        zeroed. For arrays with ``ndim`` exceeding 2, `triu` will apply to the
        final two axes.

        Please refer to the documentation for `tril` for further details.

        See Also
        --------
        tril : lower triangle of an array

        Examples
        --------
        >>> import numpy as np
        >>> 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]])

        >>> np.triu(np.arange(3*4*5).reshape(3, 4, 5))
        array([[[ 0,  1,  2,  3,  4],
                [ 0,  6,  7,  8,  9],
                [ 0,  0, 12, 13, 14],
                [ 0,  0,  0, 18, 19]],
               [[20, 21, 22, 23, 24],
                [ 0, 26, 27, 28, 29],
                [ 0,  0, 32, 33, 34],
                [ 0,  0,  0, 38, 39]],
               [[40, 41, 42, 43, 44],
                [ 0, 46, 47, 48, 49],
                [ 0,  0, 52, 53, 54],
                [ 0,  0,  0, 58, 59]]])

    triu_indices(n, k=0, m=None)
        Return the indices for the upper-triangle of an (n, m) array.

        Parameters
        ----------
        n : int
            The size of the arrays for which the returned indices will
            be valid.
        k : int, optional
            Diagonal offset (see `triu` for details).
        m : int, optional
            .. versionadded:: 1.9.0

            The column dimension of the arrays for which the returned
            arrays will be valid.
            By default `m` is taken equal to `n`.


        Returns
        -------
        inds : tuple, shape(2) of ndarrays, shape(`n`)
            The indices for the triangle. The returned tuple contains two arrays,
            each with the indices along one dimension of the array.  Can be used
            to slice a ndarray of shape(`n`, `n`).

        See also
        --------
        tril_indices : similar function, for lower-triangular.
        mask_indices : generic function accepting an arbitrary mask function.
        triu, tril

        Notes
        -----
        .. versionadded:: 1.4.0

        Examples
        --------
        >>> import numpy as np

        Compute two different sets of indices to access 4x4 arrays, one for the
        upper triangular part starting at the main diagonal, and one starting two
        diagonals further right:

        >>> iu1 = np.triu_indices(4)
        >>> iu2 = np.triu_indices(4, 2)

        Here is how they can be used with a sample array:

        >>> a = np.arange(16).reshape(4, 4)
        >>> a
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15]])

        Both for indexing:

        >>> a[iu1]
        array([ 0,  1,  2, ..., 10, 11, 15])

        And for assigning values:

        >>> a[iu1] = -1
        >>> a
        array([[-1, -1, -1, -1],
               [ 4, -1, -1, -1],
               [ 8,  9, -1, -1],
               [12, 13, 14, -1]])

        These cover only a small part of the whole array (two diagonals right
        of the main one):

        >>> a[iu2] = -10
        >>> a
        array([[ -1,  -1, -10, -10],
               [  4,  -1,  -1, -10],
               [  8,   9,  -1,  -1],
               [ 12,  13,  14,  -1]])

    triu_indices_from(arr, k=0)
        Return the indices for the upper-triangle of arr.

        See `triu_indices` for full details.

        Parameters
        ----------
        arr : ndarray, shape(N, N)
            The indices will be valid for square arrays.
        k : int, optional
            Diagonal offset (see `triu` for details).

        Returns
        -------
        triu_indices_from : tuple, shape(2) of ndarray, shape(N)
            Indices for the upper-triangle of `arr`.

        Examples
        --------
        >>> import numpy as np

        Create a 4 by 4 array

        >>> a = np.arange(16).reshape(4, 4)
        >>> a
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15]])

        Pass the array to get the indices of the upper triangular elements.

        >>> triui = np.triu_indices_from(a)
        >>> triui
        (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3]))

        >>> a[triui]
        array([ 0,  1,  2,  3,  5,  6,  7, 10, 11, 15])

        This is syntactic sugar for triu_indices().

        >>> np.triu_indices(a.shape[0])
        (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3]))

        Use the `k` parameter to return the indices for the upper triangular array
        from the k-th diagonal.

        >>> triuim1 = np.triu_indices_from(a, k=1)
        >>> a[triuim1]
        array([ 1,  2,  3,  6,  7, 11])


        See Also
        --------
        triu_indices, triu, tril_indices_from

        Notes
        -----
        .. versionadded:: 1.4.0

    typename(char)
        Return a description for the given data type code.

        Parameters
        ----------
        char : str
            Data type code.

        Returns
        -------
        out : str
            Description of the input data type code.

        See Also
        --------
        dtype

        Examples
        --------
        >>> import numpy as np
        >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
        ...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
        >>> for typechar in typechars:
        ...     print(typechar, ' : ', np.typename(typechar))
        ...
        S1  :  character
        ?  :  bool
        B  :  unsigned char
        D  :  complex double precision
        G  :  complex long double precision
        F  :  complex single precision
        I  :  unsigned integer
        H  :  unsigned short
        L  :  unsigned long integer
        O  :  object
        Q  :  unsigned long long integer
        S  :  string
        U  :  unicode
        V  :  void
        b  :  signed char
        d  :  double precision
        g  :  long precision
        f  :  single precision
        i  :  integer
        h  :  short
        l  :  long integer
        q  :  long long integer

    union1d(ar1, ar2)
        Find the union of two arrays.

        Return the unique, sorted array of values that are in either of the two
        input arrays.

        Parameters
        ----------
        ar1, ar2 : array_like
            Input arrays. They are flattened if they are not already 1D.

        Returns
        -------
        union1d : ndarray
            Unique, sorted union of the input arrays.

        Examples
        --------
        >>> import numpy as np
        >>> np.union1d([-1, 0, 1], [-2, 0, 2])
        array([-2, -1,  0,  1,  2])

        To find the union of more than two arrays, use functools.reduce:

        >>> from functools import reduce
        >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
        array([1, 2, 3, 4, 6])

    unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True)
        Find the unique elements of an array.

        Returns the sorted unique elements of an array. There are three optional
        outputs in addition to the unique elements:

        * the indices of the input array that give the unique values
        * the indices of the unique array that reconstruct the input array
        * the number of times each unique value comes up in the input array

        Parameters
        ----------
        ar : array_like
            Input array. Unless `axis` is specified, this will be flattened if it
            is not already 1-D.
        return_index : bool, optional
            If True, also return the indices of `ar` (along the specified axis,
            if provided, or in the flattened array) that result in the unique array.
        return_inverse : bool, optional
            If True, also return the indices of the unique array (for the specified
            axis, if provided) that can be used to reconstruct `ar`.
        return_counts : bool, optional
            If True, also return the number of times each unique item appears
            in `ar`.
        axis : int or None, optional
            The axis to operate on. If None, `ar` will be flattened. If an integer,
            the subarrays indexed by the given axis will be flattened and treated
            as the elements of a 1-D array with the dimension of the given axis,
            see the notes for more details.  Object arrays or structured arrays
            that contain objects are not supported if the `axis` kwarg is used. The
            default is None.

            .. versionadded:: 1.13.0

        equal_nan : bool, optional
            If True, collapses multiple NaN values in the return array into one.

            .. versionadded:: 1.24

        Returns
        -------
        unique : ndarray
            The sorted unique values.
        unique_indices : ndarray, optional
            The indices of the first occurrences of the unique values in the
            original array. Only provided if `return_index` is True.
        unique_inverse : ndarray, optional
            The indices to reconstruct the original array from the
            unique array. Only provided if `return_inverse` is True.
        unique_counts : ndarray, optional
            The number of times each of the unique values comes up in the
            original array. Only provided if `return_counts` is True.

            .. versionadded:: 1.9.0

        See Also
        --------
        repeat : Repeat elements of an array.

        Notes
        -----
        When an axis is specified the subarrays indexed by the axis are sorted.
        This is done by making the specified axis the first dimension of the array
        (move the axis to the first dimension to keep the order of the other axes)
        and then flattening the subarrays in C order. The flattened subarrays are
        then viewed as a structured type with each element given a label, with the
        effect that we end up with a 1-D array of structured types that can be
        treated in the same way as any other 1-D array. The result is that the
        flattened subarrays are sorted in lexicographic order starting with the
        first element.

        .. versionchanged: 1.21
            If nan values are in the input array, a single nan is put
            to the end of the sorted unique values.

            Also for complex arrays all NaN values are considered equivalent
            (no matter whether the NaN is in the real or imaginary part).
            As the representant for the returned array the smallest one in the
            lexicographical order is chosen - see np.sort for how the lexicographical
            order is defined for complex arrays.

        .. versionchanged: 2.0
            For multi-dimensional inputs, ``unique_inverse`` is reshaped
            such that the input can be reconstructed using
            ``np.take(unique, unique_inverse, axis=axis)``. The result is
            now not 1-dimensional when ``axis=None``.

            Note that in NumPy 2.0.0 a higher dimensional array was returned also
            when ``axis`` was not ``None``.  This was reverted, but
            ``inverse.reshape(-1)`` can be used to ensure compatibility with both
            versions.

        Examples
        --------
        >>> import numpy as np
        >>> np.unique([1, 1, 2, 2, 3, 3])
        array([1, 2, 3])
        >>> a = np.array([[1, 1], [2, 3]])
        >>> np.unique(a)
        array([1, 2, 3])

        Return the unique rows of a 2D array

        >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
        >>> np.unique(a, axis=0)
        array([[1, 0, 0], [2, 3, 4]])

        Return the indices of the original array that give the unique values:

        >>> a = np.array(['a', 'b', 'b', 'c', 'a'])
        >>> u, indices = np.unique(a, return_index=True)
        >>> u
        array(['a', 'b', 'c'], dtype='<U1')
        >>> indices
        array([0, 1, 3])
        >>> a[indices]
        array(['a', 'b', 'c'], dtype='<U1')

        Reconstruct the input array from the unique values and inverse:

        >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
        >>> u, indices = np.unique(a, return_inverse=True)
        >>> u
        array([1, 2, 3, 4, 6])
        >>> indices
        array([0, 1, 4, 3, 1, 2, 1])
        >>> u[indices]
        array([1, 2, 6, 4, 2, 3, 2])

        Reconstruct the input values from the unique values and counts:

        >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
        >>> values, counts = np.unique(a, return_counts=True)
        >>> values
        array([1, 2, 3, 4, 6])
        >>> counts
        array([1, 3, 1, 1, 1])
        >>> np.repeat(values, counts)
        array([1, 2, 2, 2, 3, 4, 6])    # original order not preserved

    unique_all(x)
        Find the unique elements of an array, and counts, inverse and indices.

        This function is an Array API compatible alternative to:

        >>> x = np.array([1, 1, 2])
        >>> np.unique(x, return_index=True, return_inverse=True,
        ...           return_counts=True, equal_nan=False)
        (array([1, 2]), array([0, 2]), array([0, 0, 1]), array([2, 1]))

        Parameters
        ----------
        x : array_like
            Input array. It will be flattened if it is not already 1-D.

        Returns
        -------
        out : namedtuple
            The result containing:

            * values - The unique elements of an input array.
            * indices - The first occurring indices for each unique element.
            * inverse_indices - The indices from the set of unique elements
              that reconstruct `x`.
            * counts - The corresponding counts for each unique element.

        See Also
        --------
        unique : Find the unique elements of an array.

        Examples
        --------
        >>> import numpy as np
        >>> np.unique_all([1, 1, 2])
        UniqueAllResult(values=array([1, 2]),
                        indices=array([0, 2]),
                        inverse_indices=array([0, 0, 1]),
                        counts=array([2, 1]))

    unique_counts(x)
        Find the unique elements and counts of an input array `x`.

        This function is an Array API compatible alternative to:

        >>> x = np.array([1, 1, 2])
        >>> np.unique(x, return_counts=True, equal_nan=False)
        (array([1, 2]), array([2, 1]))

        Parameters
        ----------
        x : array_like
            Input array. It will be flattened if it is not already 1-D.

        Returns
        -------
        out : namedtuple
            The result containing:

            * values - The unique elements of an input array.
            * counts - The corresponding counts for each unique element.

        See Also
        --------
        unique : Find the unique elements of an array.

        Examples
        --------
        >>> import numpy as np
        >>> np.unique_counts([1, 1, 2])
        UniqueCountsResult(values=array([1, 2]), counts=array([2, 1]))

    unique_inverse(x)
        Find the unique elements of `x` and indices to reconstruct `x`.

        This function is Array API compatible alternative to:

        >>> x = np.array([1, 1, 2])
        >>> np.unique(x, return_inverse=True, equal_nan=False)
        (array([1, 2]), array([0, 0, 1]))

        Parameters
        ----------
        x : array_like
            Input array. It will be flattened if it is not already 1-D.

        Returns
        -------
        out : namedtuple
            The result containing:

            * values - The unique elements of an input array.
            * inverse_indices - The indices from the set of unique elements
              that reconstruct `x`.

        See Also
        --------
        unique : Find the unique elements of an array.

        Examples
        --------
        >>> import numpy as np
        >>> np.unique_inverse([1, 1, 2])
        UniqueInverseResult(values=array([1, 2]), inverse_indices=array([0, 0, 1]))

    unique_values(x)
        Returns the unique elements of an input array `x`.

        This function is Array API compatible alternative to:

        >>> x = np.array([1, 1, 2])
        >>> np.unique(x, equal_nan=False)
        array([1, 2])

        Parameters
        ----------
        x : array_like
            Input array. It will be flattened if it is not already 1-D.

        Returns
        -------
        out : ndarray
            The unique elements of an input array.

        See Also
        --------
        unique : Find the unique elements of an array.

        Examples
        --------
        >>> import numpy as np
        >>> np.unique_values([1, 1, 2])
        array([1, 2])

    unpackbits(...)
        unpackbits(a, /, axis=None, count=None, bitorder='big')

        Unpacks elements of a uint8 array into a binary-valued output array.

        Each element of `a` represents a bit-field that should be unpacked
        into a binary-valued output array. The shape of the output array is
        either 1-D (if `axis` is ``None``) or the same shape as the input
        array with unpacking done along the axis specified.

        Parameters
        ----------
        a : ndarray, uint8 type
           Input array.
        axis : int, optional
            The dimension over which bit-unpacking is done.
            ``None`` implies unpacking the flattened array.
        count : int or None, optional
            The number of elements to unpack along `axis`, provided as a way
            of undoing the effect of packing a size that is not a multiple
            of eight. A non-negative number means to only unpack `count`
            bits. A negative number means to trim off that many bits from
            the end. ``None`` means to unpack the entire array (the
            default). Counts larger than the available number of bits will
            add zero padding to the output. Negative counts must not
            exceed the available number of bits.

            .. versionadded:: 1.17.0

        bitorder : {'big', 'little'}, optional
            The order of the returned bits. 'big' will mimic bin(val),
            ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse
            the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.
            Defaults to 'big'.

            .. versionadded:: 1.17.0

        Returns
        -------
        unpacked : ndarray, uint8 type
           The elements are binary-valued (0 or 1).

        See Also
        --------
        packbits : Packs the elements of a binary-valued array into bits in
                   a uint8 array.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[2], [7], [23]], dtype=np.uint8)
        >>> a
        array([[ 2],
               [ 7],
               [23]], dtype=uint8)
        >>> b = np.unpackbits(a, axis=1)
        >>> b
        array([[0, 0, 0, 0, 0, 0, 1, 0],
               [0, 0, 0, 0, 0, 1, 1, 1],
               [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
        >>> c = np.unpackbits(a, axis=1, count=-3)
        >>> c
        array([[0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0],
               [0, 0, 0, 1, 0]], dtype=uint8)

        >>> p = np.packbits(b, axis=0)
        >>> np.unpackbits(p, axis=0)
        array([[0, 0, 0, 0, 0, 0, 1, 0],
               [0, 0, 0, 0, 0, 1, 1, 1],
               [0, 0, 0, 1, 0, 1, 1, 1],
               [0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
        >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))
        True

    unravel_index(...)
        unravel_index(indices, shape, order='C')

        Converts a flat index or array of flat indices into a tuple
        of coordinate arrays.

        Parameters
        ----------
        indices : array_like
            An integer array whose elements are indices into the flattened
            version of an array of dimensions ``shape``. Before version 1.6.0,
            this function accepted just one index value.
        shape : tuple of ints
            The shape of the array to use for unraveling ``indices``.

            .. versionchanged:: 1.16.0
                Renamed from ``dims`` to ``shape``.

        order : {'C', 'F'}, optional
            Determines whether the indices should be viewed as indexing in
            row-major (C-style) or column-major (Fortran-style) order.

            .. versionadded:: 1.6.0

        Returns
        -------
        unraveled_coords : tuple of ndarray
            Each array in the tuple has the same shape as the ``indices``
            array.

        See Also
        --------
        ravel_multi_index

        Examples
        --------
        >>> import numpy as np
        >>> np.unravel_index([22, 41, 37], (7,6))
        (array([3, 6, 6]), array([4, 5, 1]))
        >>> np.unravel_index([31, 41, 13], (7,6), order='F')
        (array([3, 6, 6]), array([4, 5, 1]))

        >>> np.unravel_index(1621, (6,7,8,9))
        (3, 1, 4, 1)

    unstack(x, /, *, axis=0)
        Split an array into a sequence of arrays along the given axis.

        The ``axis`` parameter specifies the dimension along which the array will
        be split. For example, if ``axis=0`` (the default) it will be the first
        dimension and if ``axis=-1`` it will be the last dimension.

        The result is a tuple of arrays split along ``axis``.

        .. versionadded:: 2.1.0

        Parameters
        ----------
        x : ndarray
            The array to be unstacked.
        axis : int, optional
            Axis along which the array will be split. Default: ``0``.

        Returns
        -------
        unstacked : tuple of ndarrays
            The unstacked arrays.

        See Also
        --------
        stack : Join a sequence of arrays along a new axis.
        concatenate : Join a sequence of arrays along an existing axis.
        block : Assemble an nd-array from nested lists of blocks.
        split : Split array into a list of multiple sub-arrays of equal size.

        Notes
        -----
        ``unstack`` serves as the reverse operation of :py:func:`stack`, i.e.,
        ``stack(unstack(x, axis=axis), axis=axis) == x``.

        This function is equivalent to ``tuple(np.moveaxis(x, axis, 0))``, since
        iterating on an array iterates along the first axis.

        Examples
        --------
        >>> arr = np.arange(24).reshape((2, 3, 4))
        >>> np.unstack(arr)
        (array([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]]),
         array([[12, 13, 14, 15],
                [16, 17, 18, 19],
                [20, 21, 22, 23]]))
        >>> np.unstack(arr, axis=1)
        (array([[ 0,  1,  2,  3],
                [12, 13, 14, 15]]),
         array([[ 4,  5,  6,  7],
                [16, 17, 18, 19]]),
         array([[ 8,  9, 10, 11],
                [20, 21, 22, 23]]))
        >>> arr2 = np.stack(np.unstack(arr, axis=1), axis=1)
        >>> arr2.shape
        (2, 3, 4)
        >>> np.all(arr == arr2)
        np.True_

    unwrap(p, discont=None, axis=-1, *, period=6.283185307179586)
        Unwrap by taking the complement of large deltas with respect to the period.

        This unwraps a signal `p` by changing elements which have an absolute
        difference from their predecessor of more than ``max(discont, period/2)``
        to their `period`-complementary values.

        For the default case where `period` is :math:`2\pi` and `discont` is
        :math:`\pi`, this unwraps a radian phase `p` such that adjacent differences
        are never greater than :math:`\pi` by adding :math:`2k\pi` for some
        integer :math:`k`.

        Parameters
        ----------
        p : array_like
            Input array.
        discont : float, optional
            Maximum discontinuity between values, default is ``period/2``.
            Values below ``period/2`` are treated as if they were ``period/2``.
            To have an effect different from the default, `discont` should be
            larger than ``period/2``.
        axis : int, optional
            Axis along which unwrap will operate, default is the last axis.
        period : float, optional
            Size of the range over which the input wraps. By default, it is
            ``2 pi``.

            .. versionadded:: 1.21.0

        Returns
        -------
        out : ndarray
            Output array.

        See Also
        --------
        rad2deg, deg2rad

        Notes
        -----
        If the discontinuity in `p` is smaller than ``period/2``,
        but larger than `discont`, no unwrapping is done because taking
        the complement would only make the discontinuity larger.

        Examples
        --------
        >>> import numpy as np
        >>> phase = np.linspace(0, np.pi, num=5)
        >>> phase[3:] += np.pi
        >>> phase
        array([ 0.        ,  0.78539816,  1.57079633,  5.49778714,  6.28318531]) # may vary
        >>> np.unwrap(phase)
        array([ 0.        ,  0.78539816,  1.57079633, -0.78539816,  0.        ]) # may vary
        >>> np.unwrap([0, 1, 2, -1, 0], period=4)
        array([0, 1, 2, 3, 4])
        >>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6)
        array([1, 2, 3, 4, 5, 6, 7, 8, 9])
        >>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4)
        array([2, 3, 4, 5, 6, 7, 8, 9])
        >>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180
        >>> np.unwrap(phase_deg, period=360)
        array([-180., -140., -100.,  -60.,  -20.,   20.,   60.,  100.,  140.,
                180.,  220.,  260.,  300.,  340.,  380.,  420.,  460.,  500.,
                540.])

    vander(x, N=None, increasing=False)
        Generate a Vandermonde matrix.

        The columns of the output matrix are powers of the input vector. The
        order of the powers is determined by the `increasing` boolean argument.
        Specifically, when `increasing` is False, the `i`-th output column is
        the input vector raised element-wise to the power of ``N - i - 1``. Such
        a matrix with a geometric progression in each row is named for Alexandre-
        Theophile Vandermonde.

        Parameters
        ----------
        x : array_like
            1-D input array.
        N : int, optional
            Number of columns in the output.  If `N` is not specified, a square
            array is returned (``N = len(x)``).
        increasing : bool, optional
            Order of the powers of the columns.  If True, the powers increase
            from left to right, if False (the default) they are reversed.

            .. versionadded:: 1.9.0

        Returns
        -------
        out : ndarray
            Vandermonde matrix.  If `increasing` is False, the first column is
            ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
            True, the columns are ``x^0, x^1, ..., x^(N-1)``.

        See Also
        --------
        polynomial.polynomial.polyvander

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([1, 2, 3, 5])
        >>> N = 3
        >>> np.vander(x, N)
        array([[ 1,  1,  1],
               [ 4,  2,  1],
               [ 9,  3,  1],
               [25,  5,  1]])

        >>> np.column_stack([x**(N-1-i) for i in range(N)])
        array([[ 1,  1,  1],
               [ 4,  2,  1],
               [ 9,  3,  1],
               [25,  5,  1]])

        >>> x = np.array([1, 2, 3, 5])
        >>> np.vander(x)
        array([[  1,   1,   1,   1],
               [  8,   4,   2,   1],
               [ 27,   9,   3,   1],
               [125,  25,   5,   1]])
        >>> np.vander(x, increasing=True)
        array([[  1,   1,   1,   1],
               [  1,   2,   4,   8],
               [  1,   3,   9,  27],
               [  1,   5,  25, 125]])

        The determinant of a square Vandermonde matrix is the product
        of the differences between the values of the input vector:

        >>> np.linalg.det(np.vander(x))
        48.000000000000043 # may vary
        >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
        48

    var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>, mean=<no value>, correction=<no value>)
        Compute the variance along the specified axis.

        Returns the variance of the array elements, a measure of the spread of a
        distribution.  The variance is computed for the flattened array by
        default, otherwise over the specified axis.

        Parameters
        ----------
        a : array_like
            Array containing numbers whose variance is desired.  If `a` is not an
            array, a conversion is attempted.
        axis : None or int or tuple of ints, optional
            Axis or axes along which the variance is computed.  The default is to
            compute the variance of the flattened array.

            .. versionadded:: 1.7.0

            If this is a tuple of ints, a variance is performed over multiple axes,
            instead of a single axis or all the axes as before.
        dtype : data-type, optional
            Type to use in computing the variance.  For arrays of integer type
            the default is `float64`; for arrays of float types it is the same as
            the array type.
        out : ndarray, optional
            Alternate output array in which to place the result.  It must have
            the same shape as the expected output, but the type is cast if
            necessary.
        ddof : {int, float}, optional
            "Delta Degrees of Freedom": the divisor used in the calculation is
            ``N - ddof``, where ``N`` represents the number of elements. By
            default `ddof` is zero. See notes for details about use of `ddof`.
        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 `var` method of sub-classes of
            `ndarray`, however any non-default value will be.  If the
            sub-class' method does not implement `keepdims` any
            exceptions will be raised.
        where : array_like of bool, optional
            Elements to include in the variance. See `~numpy.ufunc.reduce` for
            details.

            .. versionadded:: 1.20.0

        mean : array like, optional
            Provide the mean to prevent its recalculation. The mean should have
            a shape as if it was calculated with ``keepdims=True``.
            The axis for the calculation of the mean should be the same as used in
            the call to this var function.

            .. versionadded:: 1.26.0

        correction : {int, float}, optional
            Array API compatible name for the ``ddof`` parameter. Only one of them
            can be provided at the same time.

            .. versionadded:: 2.0.0

        Returns
        -------
        variance : ndarray, see dtype parameter above
            If ``out=None``, returns a new array containing the variance;
            otherwise, a reference to the output array is returned.

        See Also
        --------
        std, mean, nanmean, nanstd, nanvar
        :ref:`ufuncs-output-type`

        Notes
        -----
        There are several common variants of the array variance calculation.
        Assuming the input `a` is a one-dimensional NumPy array and ``mean`` is
        either provided as an argument or computed as ``a.mean()``, NumPy
        computes the variance of an array as::

            N = len(a)
            d2 = abs(a - mean)**2  # abs is for complex `a`
            var = d2.sum() / (N - ddof)  # note use of `ddof`

        Different values of the argument `ddof` are useful in different
        contexts. NumPy's default ``ddof=0`` corresponds with the expression:

        .. math::

            \frac{\sum_i{|a_i - \bar{a}|^2 }}{N}

        which is sometimes called the "population variance" in the field of
        statistics because it applies the definition of variance to `a` as if `a`
        were a complete population of possible observations.

        Many other libraries define the variance of an array differently, e.g.:

        .. math::

            \frac{\sum_i{|a_i - \bar{a}|^2}}{N - 1}

        In statistics, the resulting quantity is sometimed called the "sample
        variance" because if `a` is a random sample from a larger population,
        this calculation provides an unbiased estimate of the variance of the
        population.  The use of :math:`N-1` in the denominator is often called
        "Bessel's correction" because it corrects for bias (toward lower values)
        in the variance estimate introduced when the sample mean of `a` is used
        in place of the true mean of the population. For this quantity, use
        ``ddof=1``.

        Note that for complex numbers, the absolute value is taken before
        squaring, so that the result is always real and nonnegative.

        For floating-point input, the variance is computed using the same
        precision the input has.  Depending on the input data, this can cause
        the results to be inaccurate, especially for `float32` (see example
        below).  Specifying a higher-accuracy accumulator using the ``dtype``
        keyword can alleviate this issue.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([[1, 2], [3, 4]])
        >>> np.var(a)
        1.25
        >>> np.var(a, axis=0)
        array([1.,  1.])
        >>> np.var(a, axis=1)
        array([0.25,  0.25])

        In single precision, var() can be inaccurate:

        >>> a = np.zeros((2, 512*512), dtype=np.float32)
        >>> a[0, :] = 1.0
        >>> a[1, :] = 0.1
        >>> np.var(a)
        0.20250003

        Computing the variance in float64 is more accurate:

        >>> np.var(a, dtype=np.float64)
        0.20249999932944759 # may vary
        >>> ((1-0.55)**2 + (0.1-0.55)**2)/2
        0.2025

        Specifying a where argument:

        >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
        >>> np.var(a)
        6.833333333333333 # may vary
        >>> np.var(a, where=[[True], [True], [False]])
        4.0

        Using the mean keyword to save computation time:

        >>> import numpy as np
        >>> from timeit import timeit
        >>>
        >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
        >>> mean = np.mean(a, axis=1, keepdims=True)
        >>>
        >>> g = globals()
        >>> n = 10000
        >>> t1 = timeit("var = np.var(a, axis=1, mean=mean)", globals=g, number=n)
        >>> t2 = timeit("var = np.var(a, axis=1)", globals=g, number=n)
        >>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%')
        #doctest: +SKIP
        Percentage execution time saved 32%

    vdot(...)
        vdot(a, b, /)

        Return the dot product of two vectors.

        The vdot(`a`, `b`) function handles complex numbers differently than
        dot(`a`, `b`).  If the first argument is complex the complex conjugate
        of the first argument is used for the calculation of the dot product.

        Note that `vdot` handles multidimensional arrays differently than `dot`:
        it does *not* perform a matrix product, but flattens input arguments
        to 1-D vectors first. Consequently, it should only be used for vectors.

        Parameters
        ----------
        a : array_like
            If `a` is complex the complex conjugate is taken before calculation
            of the dot product.
        b : array_like
            Second argument to the dot product.

        Returns
        -------
        output : ndarray
            Dot product of `a` and `b`.  Can be an int, float, or
            complex depending on the types of `a` and `b`.

        See Also
        --------
        dot : Return the dot product without using the complex conjugate of the
              first argument.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1+2j,3+4j])
        >>> b = np.array([5+6j,7+8j])
        >>> np.vdot(a, b)
        (70-8j)
        >>> np.vdot(b, a)
        (70+8j)

        Note that higher-dimensional arrays are flattened!

        >>> a = np.array([[1, 4], [5, 6]])
        >>> b = np.array([[4, 1], [2, 2]])
        >>> np.vdot(a, b)
        30
        >>> np.vdot(b, a)
        30
        >>> 1*4 + 4*1 + 5*2 + 6*2
        30

    vsplit(ary, indices_or_sections)
        Split an array into multiple sub-arrays vertically (row-wise).

        Please refer to the ``split`` documentation.  ``vsplit`` is equivalent
        to ``split`` with `axis=0` (default), the array is always split along the
        first axis regardless of the array dimension.

        See Also
        --------
        split : Split an array into multiple sub-arrays of equal size.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(16.0).reshape(4, 4)
        >>> x
        array([[ 0.,   1.,   2.,   3.],
               [ 4.,   5.,   6.,   7.],
               [ 8.,   9.,  10.,  11.],
               [12.,  13.,  14.,  15.]])
        >>> np.vsplit(x, 2)
        [array([[0., 1., 2., 3.],
                [4., 5., 6., 7.]]),
         array([[ 8.,  9., 10., 11.],
                [12., 13., 14., 15.]])]
        >>> np.vsplit(x, np.array([3, 6]))
        [array([[ 0.,  1.,  2.,  3.],
                [ 4.,  5.,  6.,  7.],
                [ 8.,  9., 10., 11.]]),
         array([[12., 13., 14., 15.]]),
         array([], shape=(0, 4), dtype=float64)]

        With a higher dimensional array the split is still along the first axis.

        >>> x = np.arange(8.0).reshape(2, 2, 2)
        >>> x
        array([[[0.,  1.],
                [2.,  3.]],
               [[4.,  5.],
                [6.,  7.]]])
        >>> np.vsplit(x, 2)
        [array([[[0., 1.],
                 [2., 3.]]]),
         array([[[4., 5.],
                 [6., 7.]]])]

    vstack(tup, *, dtype=None, casting='same_kind')
        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.

        dtype : str or dtype
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`.

            .. versionadded:: 1.24

        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur. Defaults to 'same_kind'.

            .. versionadded:: 1.24

        Returns
        -------
        stacked : ndarray
            The array formed by stacking the given arrays, will be at least 2-D.

        See Also
        --------
        concatenate : Join a sequence of arrays along an existing axis.
        stack : Join a sequence of arrays along a new axis.
        block : Assemble an nd-array from nested lists of blocks.
        hstack : Stack arrays in sequence horizontally (column wise).
        dstack : Stack arrays in sequence depth wise (along third axis).
        column_stack : Stack 1-D arrays as columns into a 2-D array.
        vsplit : Split an array into multiple sub-arrays vertically (row-wise).
        unstack : Split an array into a tuple of sub-arrays along an axis.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([1, 2, 3])
        >>> b = np.array([4, 5, 6])
        >>> np.vstack((a,b))
        array([[1, 2, 3],
               [4, 5, 6]])

        >>> a = np.array([[1], [2], [3]])
        >>> b = np.array([[4], [5], [6]])
        >>> np.vstack((a,b))
        array([[1],
               [2],
               [3],
               [4],
               [5],
               [6]])

    where(...)
        where(condition, [x, y], /)

        Return elements chosen from `x` or `y` depending on `condition`.

        .. note::
            When only `condition` is provided, this function is a shorthand for
            ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be
            preferred, as it behaves correctly for subclasses. The rest of this
            documentation covers only the case where all three arguments are
            provided.

        Parameters
        ----------
        condition : array_like, bool
            Where True, yield `x`, otherwise yield `y`.
        x, y : array_like
            Values from which to choose. `x`, `y` and `condition` need to be
            broadcastable to some shape.

        Returns
        -------
        out : ndarray
            An array with elements from `x` where `condition` is True, and elements
            from `y` elsewhere.

        See Also
        --------
        choose
        nonzero : The function that is called when x and y are omitted

        Notes
        -----
        If all the arrays are 1-D, `where` is equivalent to::

            [xv if c else yv
             for c, xv, yv in zip(condition, x, y)]

        Examples
        --------
        >>> import numpy as np
        >>> a = np.arange(10)
        >>> a
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        >>> np.where(a < 5, a, 10*a)
        array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])

        This can be used on multidimensional arrays too:

        >>> np.where([[True, False], [True, True]],
        ...          [[1, 2], [3, 4]],
        ...          [[9, 8], [7, 6]])
        array([[1, 8],
               [3, 4]])

        The shapes of x, y, and the condition are broadcast together:

        >>> x, y = np.ogrid[:3, :4]
        >>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
        array([[10,  0,  0,  0],
               [10, 11,  1,  1],
               [10, 11, 12,  2]])

        >>> a = np.array([[0, 1, 2],
        ...               [0, 2, 4],
        ...               [0, 3, 6]])
        >>> np.where(a < 4, a, -1)  # -1 is broadcast
        array([[ 0,  1,  2],
               [ 0,  2, -1],
               [ 0,  3, -1]])

    zeros(...)
        zeros(shape, dtype=float, order='C', *, like=None)

        Return a new array of given shape and type, filled with zeros.

        Parameters
        ----------
        shape : int or tuple 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, default: 'C'
            Whether to store multi-dimensional data in row-major
            (C-style) or column-major (Fortran-style) order in
            memory.
        like : array_like, optional
            Reference object to allow the creation of arrays which are not
            NumPy arrays. If an array-like passed in as ``like`` supports
            the ``__array_function__`` protocol, the result will be defined
            by it. In this case, it ensures the creation of an array object
            compatible with that passed in via this argument.

            .. versionadded:: 1.20.0

        Returns
        -------
        out : ndarray
            Array of zeros with the given shape, dtype, and order.

        See Also
        --------
        zeros_like : Return an array of zeros with shape and type of input.
        empty : Return a new uninitialized array.
        ones : Return a new array setting values to one.
        full : Return a new array of given shape filled with value.

        Examples
        --------
        >>> import numpy as np
        >>> np.zeros(5)
        array([ 0.,  0.,  0.,  0.,  0.])

        >>> np.zeros((5,), dtype=int)
        array([0, 0, 0, 0, 0])

        >>> np.zeros((2, 1))
        array([[ 0.],
               [ 0.]])

        >>> s = (2,2)
        >>> np.zeros(s)
        array([[ 0.,  0.],
               [ 0.,  0.]])

        >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
        array([(0, 0), (0, 0)],
              dtype=[('x', '<i4'), ('y', '<i4')])

    zeros_like(a, dtype=None, order='K', subok=True, shape=None, *, device=None)
        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.
        shape : int or sequence of ints, optional.
            Overrides the shape of the result. If order='K' and the number of
            dimensions is unchanged, will try to keep order, otherwise,
            order='C' is implied.

            .. versionadded:: 1.17.0
        device : str, optional
            The device on which to place the created array. Default: None.
            For Array-API interoperability only, so must be ``"cpu"`` if passed.

            .. versionadded:: 2.0.0

        Returns
        -------
        out : ndarray
            Array of zeros with the same shape and type as `a`.

        See Also
        --------
        empty_like : Return an empty array with shape and type of input.
        ones_like : Return an array of ones with shape and type of input.
        full_like : Return a new array with shape of input filled with value.
        zeros : Return a new array setting values to zero.

        Examples
        --------
        >>> import numpy as np
        >>> 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.])

DATA
    False_ = np.False_
    ScalarType = (<class 'int'>, <class 'float'>, <class 'complex'>, <clas...
    True_ = np.True_
    __NUMPY_SETUP__ = False
    __all__ = ['complex128', 'var', 'promote_types', 'full', 'ScalarType',...
    __array_api_version__ = '2023.12'
    __expired_attributes__ = {'DataSource': "It's still available as `np.l...
    __former_attrs__ = {'complex': "module 'numpy' has no attribute 'compl...
    __future_scalars__ = {'bytes', 'object', 'str'}
    __numpy_submodules__ = {'char', 'core', 'ctypeslib', 'dtypes', 'except...
    abs = <ufunc 'absolute'>
        absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Calculate the absolute value element-wise.

        ``np.abs`` is a shorthand for this function.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        absolute : ndarray
            An ndarray containing the absolute value of
            each element in `x`.  For complex input, ``a + ib``, the
            absolute value is :math:`\sqrt{ a^2 + b^2 }`.
            This is a scalar if `x` is a scalar.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([-1.2, 1.2])
        >>> np.absolute(x)
        array([ 1.2,  1.2])
        >>> np.absolute(1.2 + 1j)
        1.5620499351813308

        Plot the function over ``[-10, 10]``:

        >>> import matplotlib.pyplot as plt

        >>> x = np.linspace(start=-10, stop=10, num=101)
        >>> plt.plot(x, np.absolute(x))
        >>> plt.show()

        Plot the function over the complex plane:

        >>> xx = x + 1j * x[:, np.newaxis]
        >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
        >>> plt.show()

        The `abs` function can be used as a shorthand for ``np.absolute`` on
        ndarrays.

        >>> x = np.array([-1.2, 1.2])
        >>> abs(x)
        array([1.2, 1.2])

    absolute = <ufunc 'absolute'>
        absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Calculate the absolute value element-wise.

        ``np.abs`` is a shorthand for this function.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        absolute : ndarray
            An ndarray containing the absolute value of
            each element in `x`.  For complex input, ``a + ib``, the
            absolute value is :math:`\sqrt{ a^2 + b^2 }`.
            This is a scalar if `x` is a scalar.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([-1.2, 1.2])
        >>> np.absolute(x)
        array([ 1.2,  1.2])
        >>> np.absolute(1.2 + 1j)
        1.5620499351813308

        Plot the function over ``[-10, 10]``:

        >>> import matplotlib.pyplot as plt

        >>> x = np.linspace(start=-10, stop=10, num=101)
        >>> plt.plot(x, np.absolute(x))
        >>> plt.show()

        Plot the function over the complex plane:

        >>> xx = x + 1j * x[:, np.newaxis]
        >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
        >>> plt.show()

        The `abs` function can be used as a shorthand for ``np.absolute`` on
        ndarrays.

        >>> x = np.array([-1.2, 1.2])
        >>> abs(x)
        array([1.2, 1.2])

    acos = <ufunc 'arccos'>
        arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Trigonometric inverse cosine, element-wise.

        The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.

        Parameters
        ----------
        x : array_like
            `x`-coordinate on the unit circle.
            For real arguments, the domain is [-1, 1].
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        angle : ndarray
            The angle of the ray intersecting the unit circle at the given
            `x`-coordinate in radians [0, pi].
            This is a scalar if `x` is a scalar.

        See Also
        --------
        cos, arctan, arcsin, emath.arccos

        Notes
        -----
        `arccos` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that ``cos(z) = x``. The convention is to return
        the angle `z` whose real part lies in `[0, pi]`.

        For real-valued input data types, `arccos` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arccos` is a complex analytic function that
        has branch cuts ``[-inf, -1]`` and `[1, inf]` and is continuous from
        above on the former and from below on the latter.

        The inverse `cos` is also known as `acos` or cos^-1.

        References
        ----------
        M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
        10th printing, 1964, pp. 79.
        https://personal.math.ubc.ca/~cbm/aands/page_79.htm

        Examples
        --------
        >>> import numpy as np

        We expect the arccos of 1 to be 0, and of -1 to be pi:

        >>> np.arccos([1, -1])
        array([ 0.        ,  3.14159265])

        Plot arccos:

        >>> import matplotlib.pyplot as plt
        >>> x = np.linspace(-1, 1, num=100)
        >>> plt.plot(x, np.arccos(x))
        >>> plt.axis('tight')
        >>> plt.show()

    acosh = <ufunc 'arccosh'>
        arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse hyperbolic cosine, element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        arccosh : ndarray
            Array of the same shape as `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------

        cosh, arcsinh, sinh, arctanh, tanh

        Notes
        -----
        `arccosh` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that `cosh(z) = x`. The convention is to return the
        `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in
        ``[0, inf]``.

        For real-valued input data types, `arccosh` always returns real output.
        For each value that cannot be expressed as a real number or infinity, it
        yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arccosh` is a complex analytical function that
        has a branch cut `[-inf, 1]` and is continuous from above on it.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 86.
               https://personal.math.ubc.ca/~cbm/aands/page_86.htm
        .. [2] Wikipedia, "Inverse hyperbolic function",
               https://en.wikipedia.org/wiki/Arccosh

        Examples
        --------
        >>> import numpy as np
        >>> np.arccosh([np.e, 10.0])
        array([ 1.65745445,  2.99322285])
        >>> np.arccosh(1)
        0.0

    add = <ufunc 'add'>
        add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Add arguments element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            The arrays to be added.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        add : ndarray or scalar
            The sum of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        Notes
        -----
        Equivalent to `x1` + `x2` in terms of array broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.add(1.0, 4.0)
        5.0
        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> np.add(x1, x2)
        array([[  0.,   2.,   4.],
               [  3.,   5.,   7.],
               [  6.,   8.,  10.]])

        The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays.

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> x1 + x2
        array([[ 0.,  2.,  4.],
               [ 3.,  5.,  7.],
               [ 6.,  8., 10.]])

    arccos = <ufunc 'arccos'>
        arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Trigonometric inverse cosine, element-wise.

        The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.

        Parameters
        ----------
        x : array_like
            `x`-coordinate on the unit circle.
            For real arguments, the domain is [-1, 1].
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        angle : ndarray
            The angle of the ray intersecting the unit circle at the given
            `x`-coordinate in radians [0, pi].
            This is a scalar if `x` is a scalar.

        See Also
        --------
        cos, arctan, arcsin, emath.arccos

        Notes
        -----
        `arccos` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that ``cos(z) = x``. The convention is to return
        the angle `z` whose real part lies in `[0, pi]`.

        For real-valued input data types, `arccos` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arccos` is a complex analytic function that
        has branch cuts ``[-inf, -1]`` and `[1, inf]` and is continuous from
        above on the former and from below on the latter.

        The inverse `cos` is also known as `acos` or cos^-1.

        References
        ----------
        M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
        10th printing, 1964, pp. 79.
        https://personal.math.ubc.ca/~cbm/aands/page_79.htm

        Examples
        --------
        >>> import numpy as np

        We expect the arccos of 1 to be 0, and of -1 to be pi:

        >>> np.arccos([1, -1])
        array([ 0.        ,  3.14159265])

        Plot arccos:

        >>> import matplotlib.pyplot as plt
        >>> x = np.linspace(-1, 1, num=100)
        >>> plt.plot(x, np.arccos(x))
        >>> plt.axis('tight')
        >>> plt.show()

    arccosh = <ufunc 'arccosh'>
        arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse hyperbolic cosine, element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        arccosh : ndarray
            Array of the same shape as `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------

        cosh, arcsinh, sinh, arctanh, tanh

        Notes
        -----
        `arccosh` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that `cosh(z) = x`. The convention is to return the
        `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in
        ``[0, inf]``.

        For real-valued input data types, `arccosh` always returns real output.
        For each value that cannot be expressed as a real number or infinity, it
        yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arccosh` is a complex analytical function that
        has a branch cut `[-inf, 1]` and is continuous from above on it.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 86.
               https://personal.math.ubc.ca/~cbm/aands/page_86.htm
        .. [2] Wikipedia, "Inverse hyperbolic function",
               https://en.wikipedia.org/wiki/Arccosh

        Examples
        --------
        >>> import numpy as np
        >>> np.arccosh([np.e, 10.0])
        array([ 1.65745445,  2.99322285])
        >>> np.arccosh(1)
        0.0

    arcsin = <ufunc 'arcsin'>
        arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse sine, element-wise.

        Parameters
        ----------
        x : array_like
            `y`-coordinate on the unit circle.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        angle : ndarray
            The inverse sine of each element in `x`, in radians and in the
            closed interval ``[-pi/2, pi/2]``.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        sin, cos, arccos, tan, arctan, arctan2, emath.arcsin

        Notes
        -----
        `arcsin` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that :math:`sin(z) = x`.  The convention is to
        return the angle `z` whose real part lies in [-pi/2, pi/2].

        For real-valued input data types, *arcsin* always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arcsin` is a complex analytic function that
        has, by convention, the branch cuts [-inf, -1] and [1, inf]  and is
        continuous from above on the former and from below on the latter.

        The inverse sine is also known as `asin` or sin^{-1}.

        References
        ----------
        Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
        10th printing, New York: Dover, 1964, pp. 79ff.
        https://personal.math.ubc.ca/~cbm/aands/page_79.htm

        Examples
        --------
        >>> import numpy as np
        >>> np.arcsin(1)     # pi/2
        1.5707963267948966
        >>> np.arcsin(-1)    # -pi/2
        -1.5707963267948966
        >>> np.arcsin(0)
        0.0

    arcsinh = <ufunc 'arcsinh'>
        arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse hyperbolic sine element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Array of the same shape as `x`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        `arcsinh` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that `sinh(z) = x`. The convention is to return the
        `z` whose imaginary part lies in `[-pi/2, pi/2]`.

        For real-valued input data types, `arcsinh` always returns real output.
        For each value that cannot be expressed as a real number or infinity, it
        returns ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arcsinh` is a complex analytical function that
        has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from
        the right on the former and from the left on the latter.

        The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 86.
               https://personal.math.ubc.ca/~cbm/aands/page_86.htm
        .. [2] Wikipedia, "Inverse hyperbolic function",
               https://en.wikipedia.org/wiki/Arcsinh

        Examples
        --------
        >>> import numpy as np
        >>> np.arcsinh(np.array([np.e, 10.0]))
        array([ 1.72538256,  2.99822295])

    arctan = <ufunc 'arctan'>
        arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Trigonometric inverse tangent, element-wise.

        The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.

        Parameters
        ----------
        x : array_like
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Out has the same shape as `x`.  Its real part is in
            ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
            This is a scalar if `x` is a scalar.

        See Also
        --------
        arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`)
            and the positive `x`-axis.
        angle : Argument of complex values.

        Notes
        -----
        `arctan` is a multi-valued function: for each `x` there are infinitely
        many numbers `z` such that tan(`z`) = `x`.  The convention is to return
        the angle `z` whose real part lies in [-pi/2, pi/2].

        For real-valued input data types, `arctan` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arctan` is a complex analytic function that
        has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous
        from the left on the former and from the right on the latter.

        The inverse tangent is also known as `atan` or tan^{-1}.

        References
        ----------
        Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
        10th printing, New York: Dover, 1964, pp. 79.
        https://personal.math.ubc.ca/~cbm/aands/page_79.htm

        Examples
        --------
        We expect the arctan of 0 to be 0, and of 1 to be pi/4:

        >>> import numpy as np

        >>> np.arctan([0, 1])
        array([ 0.        ,  0.78539816])

        >>> np.pi/4
        0.78539816339744828

        Plot arctan:

        >>> import matplotlib.pyplot as plt
        >>> x = np.linspace(-10, 10)
        >>> plt.plot(x, np.arctan(x))
        >>> plt.axis('tight')
        >>> plt.show()

    arctan2 = <ufunc 'arctan2'>
        arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.

        The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is
        the signed angle in radians between the ray ending at the origin and
        passing through the point (1,0), and the ray ending at the origin and
        passing through the point (`x2`, `x1`).  (Note the role reversal: the
        "`y`-coordinate" is the first function parameter, the "`x`-coordinate"
        is the second.)  By IEEE convention, this function is defined for
        `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see
        Notes for specific values).

        This function is not defined for complex-valued arguments; for the
        so-called argument of complex values, use `angle`.

        Parameters
        ----------
        x1 : array_like, real-valued
            `y`-coordinates.
        x2 : array_like, real-valued
            `x`-coordinates.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        angle : ndarray
            Array of angles in radians, in the range ``[-pi, pi]``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        arctan, tan, angle

        Notes
        -----
        *arctan2* is identical to the `atan2` function of the underlying
        C library.  The following special values are defined in the C
        standard: [1]_

        ====== ====== ================
        `x1`   `x2`   `arctan2(x1,x2)`
        ====== ====== ================
        +/- 0  +0     +/- 0
        +/- 0  -0     +/- pi
         > 0   +/-inf +0 / +pi
         < 0   +/-inf -0 / -pi
        +/-inf +inf   +/- (pi/4)
        +/-inf -inf   +/- (3*pi/4)
        ====== ====== ================

        Note that +0 and -0 are distinct floating point numbers, as are +inf
        and -inf.

        References
        ----------
        .. [1] ISO/IEC standard 9899:1999, "Programming language C."

        Examples
        --------
        Consider four points in different quadrants:

        >>> import numpy as np

        >>> x = np.array([-1, +1, +1, -1])
        >>> y = np.array([-1, -1, +1, +1])
        >>> np.arctan2(y, x) * 180 / np.pi
        array([-135.,  -45.,   45.,  135.])

        Note the order of the parameters. `arctan2` is defined also when `x2` = 0
        and at several other special points, obtaining values in
        the range ``[-pi, pi]``:

        >>> np.arctan2([1., -1.], [0., 0.])
        array([ 1.57079633, -1.57079633])
        >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
        array([0.        , 3.14159265, 0.78539816])

    arctanh = <ufunc 'arctanh'>
        arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse hyperbolic tangent element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Array of the same shape as `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        emath.arctanh

        Notes
        -----
        `arctanh` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that ``tanh(z) = x``. The convention is to return
        the `z` whose imaginary part lies in `[-pi/2, pi/2]`.

        For real-valued input data types, `arctanh` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arctanh` is a complex analytical function
        that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
        above on the former and from below on the latter.

        The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 86.
               https://personal.math.ubc.ca/~cbm/aands/page_86.htm
        .. [2] Wikipedia, "Inverse hyperbolic function",
               https://en.wikipedia.org/wiki/Arctanh

        Examples
        --------
        >>> import numpy as np
        >>> np.arctanh([0, -0.5])
        array([ 0.        , -0.54930614])

    asin = <ufunc 'arcsin'>
        arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse sine, element-wise.

        Parameters
        ----------
        x : array_like
            `y`-coordinate on the unit circle.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        angle : ndarray
            The inverse sine of each element in `x`, in radians and in the
            closed interval ``[-pi/2, pi/2]``.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        sin, cos, arccos, tan, arctan, arctan2, emath.arcsin

        Notes
        -----
        `arcsin` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that :math:`sin(z) = x`.  The convention is to
        return the angle `z` whose real part lies in [-pi/2, pi/2].

        For real-valued input data types, *arcsin* always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arcsin` is a complex analytic function that
        has, by convention, the branch cuts [-inf, -1] and [1, inf]  and is
        continuous from above on the former and from below on the latter.

        The inverse sine is also known as `asin` or sin^{-1}.

        References
        ----------
        Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
        10th printing, New York: Dover, 1964, pp. 79ff.
        https://personal.math.ubc.ca/~cbm/aands/page_79.htm

        Examples
        --------
        >>> import numpy as np
        >>> np.arcsin(1)     # pi/2
        1.5707963267948966
        >>> np.arcsin(-1)    # -pi/2
        -1.5707963267948966
        >>> np.arcsin(0)
        0.0

    asinh = <ufunc 'arcsinh'>
        arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse hyperbolic sine element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Array of the same shape as `x`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        `arcsinh` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that `sinh(z) = x`. The convention is to return the
        `z` whose imaginary part lies in `[-pi/2, pi/2]`.

        For real-valued input data types, `arcsinh` always returns real output.
        For each value that cannot be expressed as a real number or infinity, it
        returns ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arcsinh` is a complex analytical function that
        has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from
        the right on the former and from the left on the latter.

        The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 86.
               https://personal.math.ubc.ca/~cbm/aands/page_86.htm
        .. [2] Wikipedia, "Inverse hyperbolic function",
               https://en.wikipedia.org/wiki/Arcsinh

        Examples
        --------
        >>> import numpy as np
        >>> np.arcsinh(np.array([np.e, 10.0]))
        array([ 1.72538256,  2.99822295])

    atan = <ufunc 'arctan'>
        arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Trigonometric inverse tangent, element-wise.

        The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.

        Parameters
        ----------
        x : array_like
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Out has the same shape as `x`.  Its real part is in
            ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
            This is a scalar if `x` is a scalar.

        See Also
        --------
        arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`)
            and the positive `x`-axis.
        angle : Argument of complex values.

        Notes
        -----
        `arctan` is a multi-valued function: for each `x` there are infinitely
        many numbers `z` such that tan(`z`) = `x`.  The convention is to return
        the angle `z` whose real part lies in [-pi/2, pi/2].

        For real-valued input data types, `arctan` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arctan` is a complex analytic function that
        has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous
        from the left on the former and from the right on the latter.

        The inverse tangent is also known as `atan` or tan^{-1}.

        References
        ----------
        Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
        10th printing, New York: Dover, 1964, pp. 79.
        https://personal.math.ubc.ca/~cbm/aands/page_79.htm

        Examples
        --------
        We expect the arctan of 0 to be 0, and of 1 to be pi/4:

        >>> import numpy as np

        >>> np.arctan([0, 1])
        array([ 0.        ,  0.78539816])

        >>> np.pi/4
        0.78539816339744828

        Plot arctan:

        >>> import matplotlib.pyplot as plt
        >>> x = np.linspace(-10, 10)
        >>> plt.plot(x, np.arctan(x))
        >>> plt.axis('tight')
        >>> plt.show()

    atan2 = <ufunc 'arctan2'>
        arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.

        The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is
        the signed angle in radians between the ray ending at the origin and
        passing through the point (1,0), and the ray ending at the origin and
        passing through the point (`x2`, `x1`).  (Note the role reversal: the
        "`y`-coordinate" is the first function parameter, the "`x`-coordinate"
        is the second.)  By IEEE convention, this function is defined for
        `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see
        Notes for specific values).

        This function is not defined for complex-valued arguments; for the
        so-called argument of complex values, use `angle`.

        Parameters
        ----------
        x1 : array_like, real-valued
            `y`-coordinates.
        x2 : array_like, real-valued
            `x`-coordinates.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        angle : ndarray
            Array of angles in radians, in the range ``[-pi, pi]``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        arctan, tan, angle

        Notes
        -----
        *arctan2* is identical to the `atan2` function of the underlying
        C library.  The following special values are defined in the C
        standard: [1]_

        ====== ====== ================
        `x1`   `x2`   `arctan2(x1,x2)`
        ====== ====== ================
        +/- 0  +0     +/- 0
        +/- 0  -0     +/- pi
         > 0   +/-inf +0 / +pi
         < 0   +/-inf -0 / -pi
        +/-inf +inf   +/- (pi/4)
        +/-inf -inf   +/- (3*pi/4)
        ====== ====== ================

        Note that +0 and -0 are distinct floating point numbers, as are +inf
        and -inf.

        References
        ----------
        .. [1] ISO/IEC standard 9899:1999, "Programming language C."

        Examples
        --------
        Consider four points in different quadrants:

        >>> import numpy as np

        >>> x = np.array([-1, +1, +1, -1])
        >>> y = np.array([-1, -1, +1, +1])
        >>> np.arctan2(y, x) * 180 / np.pi
        array([-135.,  -45.,   45.,  135.])

        Note the order of the parameters. `arctan2` is defined also when `x2` = 0
        and at several other special points, obtaining values in
        the range ``[-pi, pi]``:

        >>> np.arctan2([1., -1.], [0., 0.])
        array([ 1.57079633, -1.57079633])
        >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
        array([0.        , 3.14159265, 0.78539816])

    atanh = <ufunc 'arctanh'>
        arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Inverse hyperbolic tangent element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Array of the same shape as `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        emath.arctanh

        Notes
        -----
        `arctanh` is a multivalued function: for each `x` there are infinitely
        many numbers `z` such that ``tanh(z) = x``. The convention is to return
        the `z` whose imaginary part lies in `[-pi/2, pi/2]`.

        For real-valued input data types, `arctanh` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `arctanh` is a complex analytical function
        that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
        above on the former and from below on the latter.

        The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 86.
               https://personal.math.ubc.ca/~cbm/aands/page_86.htm
        .. [2] Wikipedia, "Inverse hyperbolic function",
               https://en.wikipedia.org/wiki/Arctanh

        Examples
        --------
        >>> import numpy as np
        >>> np.arctanh([0, -0.5])
        array([ 0.        , -0.54930614])

    bitwise_and = <ufunc 'bitwise_and'>
        bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the bit-wise AND of two arrays element-wise.

        Computes the bit-wise AND of the underlying binary representation of
        the integers in the input arrays. This ufunc implements the C/Python
        operator ``&``.

        Parameters
        ----------
        x1, x2 : array_like
            Only integer and boolean types are handled.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Result.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logical_and
        bitwise_or
        bitwise_xor
        binary_repr :
            Return the binary representation of the input number as a string.

        Examples
        --------
        >>> import numpy as np

        The number 13 is represented by ``00001101``.  Likewise, 17 is
        represented by ``00010001``.  The bit-wise AND of 13 and 17 is
        therefore ``000000001``, or 1:

        >>> np.bitwise_and(13, 17)
        1

        >>> np.bitwise_and(14, 13)
        12
        >>> np.binary_repr(12)
        '1100'
        >>> np.bitwise_and([14,3], 13)
        array([12,  1])

        >>> np.bitwise_and([11,7], [4,25])
        array([0, 1])
        >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
        array([ 2,  4, 16])
        >>> np.bitwise_and([True, True], [False, True])
        array([False,  True])

        The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on
        ndarrays.

        >>> x1 = np.array([2, 5, 255])
        >>> x2 = np.array([3, 14, 16])
        >>> x1 & x2
        array([ 2,  4, 16])

    bitwise_count = <ufunc 'bitwise_count'>
        bitwise_count(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Computes the number of 1-bits in the absolute value of ``x``.
        Analogous to the builtin `int.bit_count` or ``popcount`` in C++.

        Parameters
        ----------
        x : array_like, unsigned int
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding number of 1-bits in the input.
            Returns uint8 for all integer types
            This is a scalar if `x` is a scalar.

        References
        ----------
        .. [1] https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel

        .. [2] Wikipedia, "Hamming weight",
               https://en.wikipedia.org/wiki/Hamming_weight

        .. [3] http://aggregate.ee.engr.uky.edu/MAGIC/#Population%20Count%20(Ones%20Count)

        Examples
        --------
        >>> import numpy as np
        >>> np.bitwise_count(1023)
        10
        >>> a = np.array([2**i - 1 for i in range(16)])
        >>> np.bitwise_count(a)
        array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15],
              dtype=uint8)

    bitwise_invert = <ufunc 'invert'>
        invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute bit-wise inversion, or bit-wise NOT, element-wise.

        Computes the bit-wise NOT of the underlying binary representation of
        the integers in the input arrays. This ufunc implements the C/Python
        operator ``~``.

        For signed integer inputs, the bit-wise NOT of the absolute value is
        returned. In a two's-complement system, this operation effectively flips
        all the bits, resulting in a representation that corresponds to the
        negative of the input plus one. This is the most common method of
        representing signed integers on computers [1]_. A N-bit two's-complement
        system can represent every integer in the range :math:`-2^{N-1}` to
        :math:`+2^{N-1}-1`.

        Parameters
        ----------
        x : array_like
            Only integer and boolean types are handled.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Result.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        bitwise_and, bitwise_or, bitwise_xor
        logical_not
        binary_repr :
            Return the binary representation of the input number as a string.

        Notes
        -----
        ``numpy.bitwise_not`` is an alias for `invert`:

        >>> np.bitwise_not is np.invert
        True

        References
        ----------
        .. [1] Wikipedia, "Two's complement",
            https://en.wikipedia.org/wiki/Two's_complement

        Examples
        --------
        >>> import numpy as np

        We've seen that 13 is represented by ``00001101``.
        The invert or bit-wise NOT of 13 is then:

        >>> x = np.invert(np.array(13, dtype=np.uint8))
        >>> x
        242
        >>> np.binary_repr(x, width=8)
        '11110010'

        The result depends on the bit-width:

        >>> x = np.invert(np.array(13, dtype=np.uint16))
        >>> x
        65522
        >>> np.binary_repr(x, width=16)
        '1111111111110010'

        When using signed integer types, the result is the bit-wise NOT of
        the unsigned type, interpreted as a signed integer:

        >>> np.invert(np.array([13], dtype=np.int8))
        array([-14], dtype=int8)
        >>> np.binary_repr(-14, width=8)
        '11110010'

        Booleans are accepted as well:

        >>> np.invert(np.array([True, False]))
        array([False,  True])

        The ``~`` operator can be used as a shorthand for ``np.invert`` on
        ndarrays.

        >>> x1 = np.array([True, False])
        >>> ~x1
        array([False,  True])

    bitwise_left_shift = <ufunc 'left_shift'>
        left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Shift the bits of an integer to the left.

        Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
        Since the internal representation of numbers is in binary format, this
        operation is equivalent to multiplying `x1` by ``2**x2``.

        Parameters
        ----------
        x1 : array_like of integer type
            Input values.
        x2 : array_like of integer type
            Number of zeros to append to `x1`. Has to be non-negative.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : array of integer type
            Return `x1` with bits shifted `x2` times to the left.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        right_shift : Shift the bits of an integer to the right.
        binary_repr : Return the binary representation of the input number
            as a string.

        Examples
        --------
        >>> import numpy as np
        >>> np.binary_repr(5)
        '101'
        >>> np.left_shift(5, 2)
        20
        >>> np.binary_repr(20)
        '10100'

        >>> np.left_shift(5, [1,2,3])
        array([10, 20, 40])

        Note that the dtype of the second argument may change the dtype of the
        result and can lead to unexpected results in some cases (see
        :ref:`Casting Rules <ufuncs.casting>`):

        >>> a = np.left_shift(np.uint8(255), np.int64(1))  # Expect 254
        >>> print(a, type(a)) # Unexpected result due to upcasting
        510 <class 'numpy.int64'>
        >>> b = np.left_shift(np.uint8(255), np.uint8(1))
        >>> print(b, type(b))
        254 <class 'numpy.uint8'>

        The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on
        ndarrays.

        >>> x1 = 5
        >>> x2 = np.array([1, 2, 3])
        >>> x1 << x2
        array([10, 20, 40])

    bitwise_not = <ufunc 'invert'>
        invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute bit-wise inversion, or bit-wise NOT, element-wise.

        Computes the bit-wise NOT of the underlying binary representation of
        the integers in the input arrays. This ufunc implements the C/Python
        operator ``~``.

        For signed integer inputs, the bit-wise NOT of the absolute value is
        returned. In a two's-complement system, this operation effectively flips
        all the bits, resulting in a representation that corresponds to the
        negative of the input plus one. This is the most common method of
        representing signed integers on computers [1]_. A N-bit two's-complement
        system can represent every integer in the range :math:`-2^{N-1}` to
        :math:`+2^{N-1}-1`.

        Parameters
        ----------
        x : array_like
            Only integer and boolean types are handled.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Result.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        bitwise_and, bitwise_or, bitwise_xor
        logical_not
        binary_repr :
            Return the binary representation of the input number as a string.

        Notes
        -----
        ``numpy.bitwise_not`` is an alias for `invert`:

        >>> np.bitwise_not is np.invert
        True

        References
        ----------
        .. [1] Wikipedia, "Two's complement",
            https://en.wikipedia.org/wiki/Two's_complement

        Examples
        --------
        >>> import numpy as np

        We've seen that 13 is represented by ``00001101``.
        The invert or bit-wise NOT of 13 is then:

        >>> x = np.invert(np.array(13, dtype=np.uint8))
        >>> x
        242
        >>> np.binary_repr(x, width=8)
        '11110010'

        The result depends on the bit-width:

        >>> x = np.invert(np.array(13, dtype=np.uint16))
        >>> x
        65522
        >>> np.binary_repr(x, width=16)
        '1111111111110010'

        When using signed integer types, the result is the bit-wise NOT of
        the unsigned type, interpreted as a signed integer:

        >>> np.invert(np.array([13], dtype=np.int8))
        array([-14], dtype=int8)
        >>> np.binary_repr(-14, width=8)
        '11110010'

        Booleans are accepted as well:

        >>> np.invert(np.array([True, False]))
        array([False,  True])

        The ``~`` operator can be used as a shorthand for ``np.invert`` on
        ndarrays.

        >>> x1 = np.array([True, False])
        >>> ~x1
        array([False,  True])

    bitwise_or = <ufunc 'bitwise_or'>
        bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the bit-wise OR of two arrays element-wise.

        Computes the bit-wise OR of the underlying binary representation of
        the integers in the input arrays. This ufunc implements the C/Python
        operator ``|``.

        Parameters
        ----------
        x1, x2 : array_like
            Only integer and boolean types are handled.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Result.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logical_or
        bitwise_and
        bitwise_xor
        binary_repr :
            Return the binary representation of the input number as a string.

        Examples
        --------
        >>> import numpy as np

        The number 13 has the binary representation ``00001101``. Likewise,
        16 is represented by ``00010000``.  The bit-wise OR of 13 and 16 is
        then ``00011101``, or 29:

        >>> np.bitwise_or(13, 16)
        29
        >>> np.binary_repr(29)
        '11101'

        >>> np.bitwise_or(32, 2)
        34
        >>> np.bitwise_or([33, 4], 1)
        array([33,  5])
        >>> np.bitwise_or([33, 4], [1, 2])
        array([33,  6])

        >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4]))
        array([  6,   5, 255])
        >>> np.array([2, 5, 255]) | np.array([4, 4, 4])
        array([  6,   5, 255])
        >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32),
        ...               np.array([4, 4, 4, 2147483647], dtype=np.int32))
        array([         6,          5,        255, 2147483647])
        >>> np.bitwise_or([True, True], [False, True])
        array([ True,  True])

        The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on
        ndarrays.

        >>> x1 = np.array([2, 5, 255])
        >>> x2 = np.array([4, 4, 4])
        >>> x1 | x2
        array([  6,   5, 255])

    bitwise_right_shift = <ufunc 'right_shift'>
        right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Shift the bits of an integer to the right.

        Bits are shifted to the right `x2`.  Because the internal
        representation of numbers is in binary format, this operation is
        equivalent to dividing `x1` by ``2**x2``.

        Parameters
        ----------
        x1 : array_like, int
            Input values.
        x2 : array_like, int
            Number of bits to remove at the right of `x1`.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray, int
            Return `x1` with bits shifted `x2` times to the right.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        left_shift : Shift the bits of an integer to the left.
        binary_repr : Return the binary representation of the input number
            as a string.

        Examples
        --------
        >>> import numpy as np
        >>> np.binary_repr(10)
        '1010'
        >>> np.right_shift(10, 1)
        5
        >>> np.binary_repr(5)
        '101'

        >>> np.right_shift(10, [1,2,3])
        array([5, 2, 1])

        The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on
        ndarrays.

        >>> x1 = 10
        >>> x2 = np.array([1,2,3])
        >>> x1 >> x2
        array([5, 2, 1])

    bitwise_xor = <ufunc 'bitwise_xor'>
        bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the bit-wise XOR of two arrays element-wise.

        Computes the bit-wise XOR of the underlying binary representation of
        the integers in the input arrays. This ufunc implements the C/Python
        operator ``^``.

        Parameters
        ----------
        x1, x2 : array_like
            Only integer and boolean types are handled.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Result.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logical_xor
        bitwise_and
        bitwise_or
        binary_repr :
            Return the binary representation of the input number as a string.

        Examples
        --------
        >>> import numpy as np

        The number 13 is represented by ``00001101``. Likewise, 17 is
        represented by ``00010001``.  The bit-wise XOR of 13 and 17 is
        therefore ``00011100``, or 28:

        >>> np.bitwise_xor(13, 17)
        28
        >>> np.binary_repr(28)
        '11100'

        >>> np.bitwise_xor(31, 5)
        26
        >>> np.bitwise_xor([31,3], 5)
        array([26,  6])

        >>> np.bitwise_xor([31,3], [5,6])
        array([26,  5])
        >>> np.bitwise_xor([True, True], [False, True])
        array([ True, False])

        The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on
        ndarrays.

        >>> x1 = np.array([True, True])
        >>> x2 = np.array([False, True])
        >>> x1 ^ x2
        array([ True, False])

    c_ = <numpy.lib._index_tricks_impl.CClass object>
    cbrt = <ufunc 'cbrt'>
        cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the cube-root of an array, element-wise.

        .. versionadded:: 1.10.0

        Parameters
        ----------
        x : array_like
            The values whose cube-roots are required.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            An array of the same shape as `x`, containing the
            cube root of each element in `x`.
            If `out` was provided, `y` is a reference to it.
            This is a scalar if `x` is a scalar.


        Examples
        --------
        >>> import numpy as np
        >>> np.cbrt([1,8,27])
        array([ 1.,  2.,  3.])

    ceil = <ufunc 'ceil'>
        ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the ceiling of the input, element-wise.

        The ceil of the scalar `x` is the smallest integer `i`, such that
        ``i >= x``.  It is often denoted as :math:`\lceil x \rceil`.

        Parameters
        ----------
        x : array_like
            Input data.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The ceiling of each element in `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        floor, trunc, rint, fix

        Examples
        --------
        >>> import numpy as np

        >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
        >>> np.ceil(a)
        array([-1., -1., -0.,  1.,  2.,  2.,  2.])

    conj = <ufunc 'conjugate'>
        conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the complex conjugate, element-wise.

        The complex conjugate of a complex number is obtained by changing the
        sign of its imaginary part.

        Parameters
        ----------
        x : array_like
            Input value.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The complex conjugate of `x`, with same dtype as `y`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        `conj` is an alias for `conjugate`:

        >>> np.conj is np.conjugate
        True

        Examples
        --------
        >>> import numpy as np
        >>> np.conjugate(1+2j)
        (1-2j)

        >>> x = np.eye(2) + 1j * np.eye(2)
        >>> np.conjugate(x)
        array([[ 1.-1.j,  0.-0.j],
               [ 0.-0.j,  1.-1.j]])

    conjugate = <ufunc 'conjugate'>
        conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the complex conjugate, element-wise.

        The complex conjugate of a complex number is obtained by changing the
        sign of its imaginary part.

        Parameters
        ----------
        x : array_like
            Input value.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The complex conjugate of `x`, with same dtype as `y`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        `conj` is an alias for `conjugate`:

        >>> np.conj is np.conjugate
        True

        Examples
        --------
        >>> import numpy as np
        >>> np.conjugate(1+2j)
        (1-2j)

        >>> x = np.eye(2) + 1j * np.eye(2)
        >>> np.conjugate(x)
        array([[ 1.-1.j,  0.-0.j],
               [ 0.-0.j,  1.-1.j]])

    copysign = <ufunc 'copysign'>
        copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Change the sign of x1 to that of x2, element-wise.

        If `x2` is a scalar, its sign will be copied to all elements of `x1`.

        Parameters
        ----------
        x1 : array_like
            Values to change the sign of.
        x2 : array_like
            The sign of `x2` is copied to `x1`.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            The values of `x1` with the sign of `x2`.
            This is a scalar if both `x1` and `x2` are scalars.

        Examples
        --------
        >>> import numpy as np
        >>> np.copysign(1.3, -1)
        -1.3
        >>> 1/np.copysign(0, 1)
        inf
        >>> 1/np.copysign(0, -1)
        -inf

        >>> np.copysign([-1, 0, 1], -1.1)
        array([-1., -0., -1.])
        >>> np.copysign([-1, 0, 1], np.arange(3)-1)
        array([-1.,  0.,  1.])

    cos = <ufunc 'cos'>
        cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Cosine element-wise.

        Parameters
        ----------
        x : array_like
            Input array in radians.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding cosine values.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        If `out` is provided, the function writes the result into it,
        and returns a reference to `out`.  (See Examples)

        References
        ----------
        M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
        New York, NY: Dover, 1972.

        Examples
        --------
        >>> import numpy as np
        >>> np.cos(np.array([0, np.pi/2, np.pi]))
        array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])
        >>>
        >>> # Example of providing the optional output parameter
        >>> out1 = np.array([0], dtype='d')
        >>> out2 = np.cos([0.1], out1)
        >>> out2 is out1
        True
        >>>
        >>> # Example of ValueError due to provision of shape mis-matched `out`
        >>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

    cosh = <ufunc 'cosh'>
        cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Hyperbolic cosine, element-wise.

        Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array of same shape as `x`.
            This is a scalar if `x` is a scalar.

        Examples
        --------
        >>> import numpy as np
        >>> np.cosh(0)
        1.0

        The hyperbolic cosine describes the shape of a hanging cable:

        >>> import matplotlib.pyplot as plt
        >>> x = np.linspace(-4, 4, 1000)
        >>> plt.plot(x, np.cosh(x))
        >>> plt.show()

    deg2rad = <ufunc 'deg2rad'>
        deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Convert angles from degrees to radians.

        Parameters
        ----------
        x : array_like
            Angles in degrees.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding angle in radians.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        rad2deg : Convert angles from radians to degrees.
        unwrap : Remove large jumps in angle by wrapping.

        Notes
        -----
        .. versionadded:: 1.3.0

        ``deg2rad(x)`` is ``x * pi / 180``.

        Examples
        --------
        >>> import numpy as np
        >>> np.deg2rad(180)
        3.1415926535897931

    degrees = <ufunc 'degrees'>
        degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Convert angles from radians to degrees.

        Parameters
        ----------
        x : array_like
            Input array in radians.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray of floats
            The corresponding degree values; if `out` was supplied this is a
            reference to it.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        rad2deg : equivalent function

        Examples
        --------
        Convert a radian array to degrees

        >>> import numpy as np

        >>> rad = np.arange(12.)*np.pi/6
        >>> np.degrees(rad)
        array([   0.,   30.,   60.,   90.,  120.,  150.,  180.,  210.,  240.,
                270.,  300.,  330.])

        >>> out = np.zeros((rad.shape))
        >>> r = np.degrees(rad, out)
        >>> np.all(r == out)
        True

    divide = <ufunc 'divide'>
        divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Divide arguments element-wise.

        Parameters
        ----------
        x1 : array_like
            Dividend array.
        x2 : array_like
            Divisor array.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The quotient ``x1/x2``, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        seterr : Set whether to raise or warn on overflow, underflow and
                 division by zero.

        Notes
        -----
        Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting.

        The ``true_divide(x1, x2)`` function is an alias for
        ``divide(x1, x2)``.

        Examples
        --------
        >>> import numpy as np
        >>> np.divide(2.0, 4.0)
        0.5
        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> np.divide(x1, x2)
        array([[nan, 1. , 1. ],
               [inf, 4. , 2.5],
               [inf, 7. , 4. ]])

        The ``/`` operator can be used as a shorthand for ``np.divide`` on
        ndarrays.

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = 2 * np.ones(3)
        >>> x1 / x2
        array([[0. , 0.5, 1. ],
               [1.5, 2. , 2.5],
               [3. , 3.5, 4. ]])

    divmod = <ufunc 'divmod'>
        divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return element-wise quotient and remainder simultaneously.

        .. versionadded:: 1.13.0

        ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster
        because it avoids redundant work. It is used to implement the Python
        built-in function ``divmod`` on NumPy arrays.

        Parameters
        ----------
        x1 : array_like
            Dividend array.
        x2 : array_like
            Divisor array.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out1 : ndarray
            Element-wise quotient resulting from floor division.
            This is a scalar if both `x1` and `x2` are scalars.
        out2 : ndarray
            Element-wise remainder from floor division.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        floor_divide : Equivalent to Python's ``//`` operator.
        remainder : Equivalent to Python's ``%`` operator.
        modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return
               values switched.

        Examples
        --------
        >>> import numpy as np
        >>> np.divmod(np.arange(5), 3)
        (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

        The `divmod` function can be used as a shorthand for ``np.divmod`` on
        ndarrays.

        >>> x = np.arange(5)
        >>> divmod(x, 3)
        (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

    e = 2.718281828459045
    equal = <ufunc 'equal'>
        equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return (x1 == x2) element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array, element-wise comparison of `x1` and `x2`.
            Typically of type bool, unless ``dtype=object`` is passed.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        not_equal, greater_equal, less_equal, greater, less

        Examples
        --------
        >>> import numpy as np
        >>> np.equal([0, 1, 3], np.arange(3))
        array([ True,  True, False])

        What is compared are values, not types. So an int (1) and an array of
        length one can evaluate as True:

        >>> np.equal(1, np.ones(1))
        array([ True])

        The ``==`` operator can be used as a shorthand for ``np.equal`` on
        ndarrays.

        >>> a = np.array([2, 4, 6])
        >>> b = np.array([2, 4, 2])
        >>> a == b
        array([ True,  True, False])

    euler_gamma = 0.5772156649015329
    exp = <ufunc 'exp'>
        exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Calculate the exponential of all elements in the input array.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array, element-wise exponential of `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        expm1 : Calculate ``exp(x) - 1`` for all elements in the array.
        exp2  : Calculate ``2**x`` for all elements in the array.

        Notes
        -----
        The irrational number ``e`` is also known as Euler's number.  It is
        approximately 2.718281, and is the base of the natural logarithm,
        ``ln`` (this means that, if :math:`x = \ln y = \log_e y`,
        then :math:`e^x = y`. For real input, ``exp(x)`` is always positive.

        For complex arguments, ``x = a + ib``, we can write
        :math:`e^x = e^a e^{ib}`.  The first term, :math:`e^a`, is already
        known (it is the real argument, described above).  The second term,
        :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with
        magnitude 1 and a periodic phase.

        References
        ----------
        .. [1] Wikipedia, "Exponential function",
               https://en.wikipedia.org/wiki/Exponential_function
        .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions
               with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69,
               https://personal.math.ubc.ca/~cbm/aands/page_69.htm

        Examples
        --------
        Plot the magnitude and phase of ``exp(x)`` in the complex plane:

        >>> import numpy as np

        >>> import matplotlib.pyplot as plt

        >>> x = np.linspace(-2*np.pi, 2*np.pi, 100)
        >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane
        >>> out = np.exp(xx)

        >>> plt.subplot(121)
        >>> plt.imshow(np.abs(out),
        ...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')
        >>> plt.title('Magnitude of exp(x)')

        >>> plt.subplot(122)
        >>> plt.imshow(np.angle(out),
        ...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')
        >>> plt.title('Phase (angle) of exp(x)')
        >>> plt.show()

    exp2 = <ufunc 'exp2'>
        exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Calculate `2**p` for all `p` in the input array.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Element-wise 2 to the power `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        power

        Notes
        -----
        .. versionadded:: 1.3.0



        Examples
        --------
        >>> import numpy as np
        >>> np.exp2([2, 3])
        array([ 4.,  8.])

    expm1 = <ufunc 'expm1'>
        expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Calculate ``exp(x) - 1`` for all elements in the array.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Element-wise exponential minus one: ``out = exp(x) - 1``.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        log1p : ``log(1 + x)``, the inverse of expm1.


        Notes
        -----
        This function provides greater precision than ``exp(x) - 1``
        for small values of ``x``.

        Examples
        --------
        The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to
        about 32 significant digits. This example shows the superiority of
        expm1 in this case.

        >>> import numpy as np

        >>> np.expm1(1e-10)
        1.00000000005e-10
        >>> np.exp(1e-10) - 1
        1.000000082740371e-10

    fabs = <ufunc 'fabs'>
        fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the absolute values element-wise.

        This function returns the absolute values (positive magnitude) of the
        data in `x`. Complex values are not handled, use `absolute` to find the
        absolute values of complex data.

        Parameters
        ----------
        x : array_like
            The array of numbers for which the absolute values are required. If
            `x` is a scalar, the result `y` will also be a scalar.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The absolute values of `x`, the returned values are always floats.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        absolute : Absolute values including `complex` types.

        Examples
        --------
        >>> import numpy as np
        >>> np.fabs(-1)
        1.0
        >>> np.fabs([-1.2, 1.2])
        array([ 1.2,  1.2])

    float_power = <ufunc 'float_power'>
        float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        First array elements raised to powers from second array, element-wise.

        Raise each base in `x1` to the positionally-corresponding power in `x2`.
        `x1` and `x2` must be broadcastable to the same shape. This differs from
        the power function in that integers, float16, and float32  are promoted to
        floats with a minimum precision of float64 so that the result is always
        inexact.  The intent is that the function will return a usable result for
        negative powers and seldom overflow for positive powers.

        Negative values raised to a non-integral value will return ``nan``.
        To get complex results, cast the input to complex, or specify the
        ``dtype`` to be ``complex`` (see the example below).

        .. versionadded:: 1.12.0

        Parameters
        ----------
        x1 : array_like
            The bases.
        x2 : array_like
            The exponents.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The bases in `x1` raised to the exponents in `x2`.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        power : power function that preserves type

        Examples
        --------
        >>> import numpy as np

        Cube each element in a list.

        >>> x1 = range(6)
        >>> x1
        [0, 1, 2, 3, 4, 5]
        >>> np.float_power(x1, 3)
        array([   0.,    1.,    8.,   27.,   64.,  125.])

        Raise the bases to different exponents.

        >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
        >>> np.float_power(x1, x2)
        array([  0.,   1.,   8.,  27.,  16.,   5.])

        The effect of broadcasting.

        >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
        >>> x2
        array([[1, 2, 3, 3, 2, 1],
               [1, 2, 3, 3, 2, 1]])
        >>> np.float_power(x1, x2)
        array([[  0.,   1.,   8.,  27.,  16.,   5.],
               [  0.,   1.,   8.,  27.,  16.,   5.]])

        Negative values raised to a non-integral value will result in ``nan``
        (and a warning will be generated).

        >>> x3 = np.array([-1, -4])
        >>> with np.errstate(invalid='ignore'):
        ...     p = np.float_power(x3, 1.5)
        ...
        >>> p
        array([nan, nan])

        To get complex results, give the argument ``dtype=complex``.

        >>> np.float_power(x3, 1.5, dtype=complex)
        array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

    floor = <ufunc 'floor'>
        floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the floor of the input, element-wise.

        The floor of the scalar `x` is the largest integer `i`, such that
        `i <= x`.  It is often denoted as :math:`\lfloor x \rfloor`.

        Parameters
        ----------
        x : array_like
            Input data.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The floor of each element in `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        ceil, trunc, rint, fix

        Notes
        -----
        Some spreadsheet programs calculate the "floor-towards-zero", where
        ``floor(-2.5) == -2``.  NumPy instead uses the definition of
        `floor` where `floor(-2.5) == -3`. The "floor-towards-zero"
        function is called ``fix`` in NumPy.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
        >>> np.floor(a)
        array([-2., -2., -1.,  0.,  1.,  1.,  2.])

    floor_divide = <ufunc 'floor_divide'>
        floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the largest integer smaller or equal to the division of the inputs.
        It is equivalent to the Python ``//`` operator and pairs with the
        Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)``
        up to roundoff.

        Parameters
        ----------
        x1 : array_like
            Numerator.
        x2 : array_like
            Denominator.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            y = floor(`x1`/`x2`)
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        remainder : Remainder complementary to floor_divide.
        divmod : Simultaneous floor division and remainder.
        divide : Standard division.
        floor : Round a number to the nearest integer toward minus infinity.
        ceil : Round a number to the nearest integer toward infinity.

        Examples
        --------
        >>> import numpy as np
        >>> np.floor_divide(7,3)
        2
        >>> np.floor_divide([1., 2., 3., 4.], 2.5)
        array([ 0.,  0.,  1.,  1.])

        The ``//`` operator can be used as a shorthand for ``np.floor_divide``
        on ndarrays.

        >>> x1 = np.array([1., 2., 3., 4.])
        >>> x1 // 2.5
        array([0., 0., 1., 1.])

    fmax = <ufunc 'fmax'>
        fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Element-wise maximum of array elements.

        Compare two arrays and return a new array containing the element-wise
        maxima. If one of the elements being compared is a NaN, then the
        non-nan element is returned. If both elements are NaNs then the first
        is returned.  The latter distinction is important for complex NaNs,
        which are defined as at least one of the real or imaginary parts being
        a NaN. The net effect is that NaNs are ignored when possible.

        Parameters
        ----------
        x1, x2 : array_like
            The arrays holding the elements to be compared.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The maximum of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        fmin :
            Element-wise minimum of two arrays, ignores NaNs.
        maximum :
            Element-wise maximum of two arrays, propagates NaNs.
        amax :
            The maximum value of an array along a given axis, propagates NaNs.
        nanmax :
            The maximum value of an array along a given axis, ignores NaNs.

        minimum, amin, nanmin

        Notes
        -----
        .. versionadded:: 1.3.0

        The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither
        x1 nor x2 are NaNs, but it is faster and does proper broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.fmax([2, 3, 4], [1, 5, 2])
        array([ 2.,  5.,  4.])

        >>> np.fmax(np.eye(2), [0.5, 2])
        array([[ 1. ,  2. ],
               [ 0.5,  2. ]])

        >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])
        array([ 0.,  0., nan])

    fmin = <ufunc 'fmin'>
        fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Element-wise minimum of array elements.

        Compare two arrays and return a new array containing the element-wise
        minima. If one of the elements being compared is a NaN, then the
        non-nan element is returned. If both elements are NaNs then the first
        is returned.  The latter distinction is important for complex NaNs,
        which are defined as at least one of the real or imaginary parts being
        a NaN. The net effect is that NaNs are ignored when possible.

        Parameters
        ----------
        x1, x2 : array_like
            The arrays holding the elements to be compared.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The minimum of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        fmax :
            Element-wise maximum of two arrays, ignores NaNs.
        minimum :
            Element-wise minimum of two arrays, propagates NaNs.
        amin :
            The minimum value of an array along a given axis, propagates NaNs.
        nanmin :
            The minimum value of an array along a given axis, ignores NaNs.

        maximum, amax, nanmax

        Notes
        -----
        .. versionadded:: 1.3.0

        The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither
        x1 nor x2 are NaNs, but it is faster and does proper broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.fmin([2, 3, 4], [1, 5, 2])
        array([1, 3, 2])

        >>> np.fmin(np.eye(2), [0.5, 2])
        array([[ 0.5,  0. ],
               [ 0. ,  1. ]])

        >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])
        array([ 0.,  0., nan])

    fmod = <ufunc 'fmod'>
        fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns the element-wise remainder of division.

        This is the NumPy implementation of the C library function fmod, the
        remainder has the same sign as the dividend `x1`. It is equivalent to
        the Matlab(TM) ``rem`` function and should not be confused with the
        Python modulus operator ``x1 % x2``.

        Parameters
        ----------
        x1 : array_like
            Dividend.
        x2 : array_like
            Divisor.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : array_like
            The remainder of the division of `x1` by `x2`.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        remainder : Equivalent to the Python ``%`` operator.
        divide

        Notes
        -----
        The result of the modulo operation for negative dividend and divisors
        is bound by conventions. For `fmod`, the sign of result is the sign of
        the dividend, while for `remainder` the sign of the result is the sign
        of the divisor. The `fmod` function is equivalent to the Matlab(TM)
        ``rem`` function.

        Examples
        --------
        >>> import numpy as np
        >>> np.fmod([-3, -2, -1, 1, 2, 3], 2)
        array([-1,  0, -1,  1,  0,  1])
        >>> np.remainder([-3, -2, -1, 1, 2, 3], 2)
        array([1, 0, 1, 1, 0, 1])

        >>> np.fmod([5, 3], [2, 2.])
        array([ 1.,  1.])
        >>> a = np.arange(-3, 3).reshape(3, 2)
        >>> a
        array([[-3, -2],
               [-1,  0],
               [ 1,  2]])
        >>> np.fmod(a, [2,2])
        array([[-1,  0],
               [-1,  0],
               [ 1,  0]])

    frexp = <ufunc 'frexp'>
        frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Decompose the elements of x into mantissa and twos exponent.

        Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``.
        The mantissa lies in the open interval(-1, 1), while the twos
        exponent is a signed integer.

        Parameters
        ----------
        x : array_like
            Array of numbers to be decomposed.
        out1 : ndarray, optional
            Output array for the mantissa. Must have the same shape as `x`.
        out2 : ndarray, optional
            Output array for the exponent. Must have the same shape as `x`.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        mantissa : ndarray
            Floating values between -1 and 1.
            This is a scalar if `x` is a scalar.
        exponent : ndarray
            Integer exponents of 2.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`.

        Notes
        -----
        Complex dtypes are not supported, they will raise a TypeError.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.arange(9)
        >>> y1, y2 = np.frexp(x)
        >>> y1
        array([ 0.   ,  0.5  ,  0.5  ,  0.75 ,  0.5  ,  0.625,  0.75 ,  0.875,
                0.5  ])
        >>> y2
        array([0, 1, 2, 2, 3, 3, 3, 3, 4])
        >>> y1 * 2**y2
        array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])

    gcd = <ufunc 'gcd'>
        gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns the greatest common divisor of ``|x1|`` and ``|x2|``

        Parameters
        ----------
        x1, x2 : array_like, int
            Arrays of values.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).

        Returns
        -------
        y : ndarray or scalar
            The greatest common divisor of the absolute value of the inputs
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        lcm : The lowest common multiple

        Examples
        --------
        >>> import numpy as np
        >>> np.gcd(12, 20)
        4
        >>> np.gcd.reduce([15, 25, 35])
        5
        >>> np.gcd(np.arange(6), 20)
        array([20,  1,  2,  1,  4,  5])

    greater = <ufunc 'greater'>
        greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the truth value of (x1 > x2) element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array, element-wise comparison of `x1` and `x2`.
            Typically of type bool, unless ``dtype=object`` is passed.
            This is a scalar if both `x1` and `x2` are scalars.


        See Also
        --------
        greater_equal, less, less_equal, equal, not_equal

        Examples
        --------
        >>> import numpy as np
        >>> np.greater([4,2],[2,2])
        array([ True, False])

        The ``>`` operator can be used as a shorthand for ``np.greater`` on
        ndarrays.

        >>> a = np.array([4, 2])
        >>> b = np.array([2, 2])
        >>> a > b
        array([ True, False])

    greater_equal = <ufunc 'greater_equal'>
        greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the truth value of (x1 >= x2) element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : bool or ndarray of bool
            Output array, element-wise comparison of `x1` and `x2`.
            Typically of type bool, unless ``dtype=object`` is passed.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        greater, less, less_equal, equal, not_equal

        Examples
        --------
        >>> import numpy as np
        >>> np.greater_equal([4, 2, 1], [2, 2, 2])
        array([ True, True, False])

        The ``>=`` operator can be used as a shorthand for ``np.greater_equal``
        on ndarrays.

        >>> a = np.array([4, 2, 1])
        >>> b = np.array([2, 2, 2])
        >>> a >= b
        array([ True,  True, False])

    heaviside = <ufunc 'heaviside'>
        heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the Heaviside step function.

        The Heaviside step function [1]_ is defined as::

                                  0   if x1 < 0
            heaviside(x1, x2) =  x2   if x1 == 0
                                  1   if x1 > 0

        where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.

        Parameters
        ----------
        x1 : array_like
            Input values.
        x2 : array_like
            The value of the function when x1 is 0.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            The output array, element-wise Heaviside step function of `x1`.
            This is a scalar if both `x1` and `x2` are scalars.

        Notes
        -----
        .. versionadded:: 1.13.0

        References
        ----------
        .. [1] Wikipedia, "Heaviside step function",
               https://en.wikipedia.org/wiki/Heaviside_step_function

        Examples
        --------
        >>> import numpy as np
        >>> np.heaviside([-1.5, 0, 2.0], 0.5)
        array([ 0. ,  0.5,  1. ])
        >>> np.heaviside([-1.5, 0, 2.0], 1)
        array([ 0.,  1.,  1.])

    hypot = <ufunc 'hypot'>
        hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Given the "legs" of a right triangle, return its hypotenuse.

        Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise.  If `x1` or
        `x2` is scalar_like (i.e., unambiguously cast-able to a scalar type),
        it is broadcast for use with each element of the other argument.
        (See Examples)

        Parameters
        ----------
        x1, x2 : array_like
            Leg of the triangle(s).
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        z : ndarray
            The hypotenuse of the triangle(s).
            This is a scalar if both `x1` and `x2` are scalars.

        Examples
        --------
        >>> import numpy as np
        >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
        array([[ 5.,  5.,  5.],
               [ 5.,  5.,  5.],
               [ 5.,  5.,  5.]])

        Example showing broadcast of scalar_like argument:

        >>> np.hypot(3*np.ones((3, 3)), [4])
        array([[ 5.,  5.,  5.],
               [ 5.,  5.,  5.],
               [ 5.,  5.,  5.]])

    index_exp = <numpy.lib._index_tricks_impl.IndexExpression object>
    inf = inf
    invert = <ufunc 'invert'>
        invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute bit-wise inversion, or bit-wise NOT, element-wise.

        Computes the bit-wise NOT of the underlying binary representation of
        the integers in the input arrays. This ufunc implements the C/Python
        operator ``~``.

        For signed integer inputs, the bit-wise NOT of the absolute value is
        returned. In a two's-complement system, this operation effectively flips
        all the bits, resulting in a representation that corresponds to the
        negative of the input plus one. This is the most common method of
        representing signed integers on computers [1]_. A N-bit two's-complement
        system can represent every integer in the range :math:`-2^{N-1}` to
        :math:`+2^{N-1}-1`.

        Parameters
        ----------
        x : array_like
            Only integer and boolean types are handled.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Result.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        bitwise_and, bitwise_or, bitwise_xor
        logical_not
        binary_repr :
            Return the binary representation of the input number as a string.

        Notes
        -----
        ``numpy.bitwise_not`` is an alias for `invert`:

        >>> np.bitwise_not is np.invert
        True

        References
        ----------
        .. [1] Wikipedia, "Two's complement",
            https://en.wikipedia.org/wiki/Two's_complement

        Examples
        --------
        >>> import numpy as np

        We've seen that 13 is represented by ``00001101``.
        The invert or bit-wise NOT of 13 is then:

        >>> x = np.invert(np.array(13, dtype=np.uint8))
        >>> x
        242
        >>> np.binary_repr(x, width=8)
        '11110010'

        The result depends on the bit-width:

        >>> x = np.invert(np.array(13, dtype=np.uint16))
        >>> x
        65522
        >>> np.binary_repr(x, width=16)
        '1111111111110010'

        When using signed integer types, the result is the bit-wise NOT of
        the unsigned type, interpreted as a signed integer:

        >>> np.invert(np.array([13], dtype=np.int8))
        array([-14], dtype=int8)
        >>> np.binary_repr(-14, width=8)
        '11110010'

        Booleans are accepted as well:

        >>> np.invert(np.array([True, False]))
        array([False,  True])

        The ``~`` operator can be used as a shorthand for ``np.invert`` on
        ndarrays.

        >>> x1 = np.array([True, False])
        >>> ~x1
        array([False,  True])

    isfinite = <ufunc 'isfinite'>
        isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Test element-wise for finiteness (not infinity and not Not a Number).

        The result is returned as a boolean array.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray, bool
            True where ``x`` is not positive infinity, negative infinity,
            or NaN; false otherwise.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        isinf, isneginf, isposinf, isnan

        Notes
        -----
        Not a Number, positive infinity and negative infinity are considered
        to be non-finite.

        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754). This means that Not a Number is not equivalent to infinity.
        Also that positive infinity is not equivalent to negative infinity. But
        infinity is equivalent to positive infinity.  Errors result if the
        second argument is also supplied when `x` is a scalar input, or if
        first and second arguments have different shapes.

        Examples
        --------
        >>> import numpy as np
        >>> np.isfinite(1)
        True
        >>> np.isfinite(0)
        True
        >>> np.isfinite(np.nan)
        False
        >>> np.isfinite(np.inf)
        False
        >>> np.isfinite(-np.inf)
        False
        >>> np.isfinite([np.log(-1.),1.,np.log(0)])
        array([False,  True, False])

        >>> x = np.array([-np.inf, 0., np.inf])
        >>> y = np.array([2, 2, 2])
        >>> np.isfinite(x, y)
        array([0, 1, 0])
        >>> y
        array([0, 1, 0])

    isinf = <ufunc 'isinf'>
        isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Test element-wise for positive or negative infinity.

        Returns a boolean array of the same shape as `x`, True where ``x ==
        +/-inf``, otherwise False.

        Parameters
        ----------
        x : array_like
            Input values
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : bool (scalar) or boolean ndarray
            True where ``x`` is positive or negative infinity, false otherwise.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        isneginf, isposinf, isnan, isfinite

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754).

        Errors result if the second argument is supplied when the first
        argument is a scalar, or if the first and second arguments have
        different shapes.

        Examples
        --------
        >>> import numpy as np
        >>> np.isinf(np.inf)
        True
        >>> np.isinf(np.nan)
        False
        >>> np.isinf(-np.inf)
        True
        >>> np.isinf([np.inf, -np.inf, 1.0, np.nan])
        array([ True,  True, False, False])

        >>> x = np.array([-np.inf, 0., np.inf])
        >>> y = np.array([2, 2, 2])
        >>> np.isinf(x, y)
        array([1, 0, 1])
        >>> y
        array([1, 0, 1])

    isnan = <ufunc 'isnan'>
        isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Test element-wise for NaN and return result as a boolean array.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or bool
            True where ``x`` is NaN, false otherwise.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        isinf, isneginf, isposinf, isfinite, isnat

        Notes
        -----
        NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
        (IEEE 754). This means that Not a Number is not equivalent to infinity.

        Examples
        --------
        >>> import numpy as np
        >>> np.isnan(np.nan)
        True
        >>> np.isnan(np.inf)
        False
        >>> np.isnan([np.log(-1.),1.,np.log(0)])
        array([ True, False, False])

    isnat = <ufunc 'isnat'>
        isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Test element-wise for NaT (not a time) and return result as a boolean array.

        .. versionadded:: 1.13.0

        Parameters
        ----------
        x : array_like
            Input array with datetime or timedelta data type.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or bool
            True where ``x`` is NaT, false otherwise.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        isnan, isinf, isneginf, isposinf, isfinite

        Examples
        --------
        >>> import numpy as np
        >>> np.isnat(np.datetime64("NaT"))
        True
        >>> np.isnat(np.datetime64("2016-01-01"))
        False
        >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]"))
        array([ True, False])

    lcm = <ufunc 'lcm'>
        lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns the lowest common multiple of ``|x1|`` and ``|x2|``

        Parameters
        ----------
        x1, x2 : array_like, int
            Arrays of values.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).

        Returns
        -------
        y : ndarray or scalar
            The lowest common multiple of the absolute value of the inputs
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        gcd : The greatest common divisor

        Examples
        --------
        >>> import numpy as np
        >>> np.lcm(12, 20)
        60
        >>> np.lcm.reduce([3, 12, 20])
        60
        >>> np.lcm.reduce([40, 12, 20])
        120
        >>> np.lcm(np.arange(6), 20)
        array([ 0, 20, 20, 60, 20, 20])

    ldexp = <ufunc 'ldexp'>
        ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns x1 * 2**x2, element-wise.

        The mantissas `x1` and twos exponents `x2` are used to construct
        floating point numbers ``x1 * 2**x2``.

        Parameters
        ----------
        x1 : array_like
            Array of multipliers.
        x2 : array_like, int
            Array of twos exponents.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The result of ``x1 * 2**x2``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`.

        Notes
        -----
        Complex dtypes are not supported, they will raise a TypeError.

        `ldexp` is useful as the inverse of `frexp`, if used by itself it is
        more clear to simply use the expression ``x1 * 2**x2``.

        Examples
        --------
        >>> import numpy as np
        >>> np.ldexp(5, np.arange(4))
        array([ 5., 10., 20., 40.], dtype=float16)

        >>> x = np.arange(6)
        >>> np.ldexp(*np.frexp(x))
        array([ 0.,  1.,  2.,  3.,  4.,  5.])

    left_shift = <ufunc 'left_shift'>
        left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Shift the bits of an integer to the left.

        Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
        Since the internal representation of numbers is in binary format, this
        operation is equivalent to multiplying `x1` by ``2**x2``.

        Parameters
        ----------
        x1 : array_like of integer type
            Input values.
        x2 : array_like of integer type
            Number of zeros to append to `x1`. Has to be non-negative.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : array of integer type
            Return `x1` with bits shifted `x2` times to the left.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        right_shift : Shift the bits of an integer to the right.
        binary_repr : Return the binary representation of the input number
            as a string.

        Examples
        --------
        >>> import numpy as np
        >>> np.binary_repr(5)
        '101'
        >>> np.left_shift(5, 2)
        20
        >>> np.binary_repr(20)
        '10100'

        >>> np.left_shift(5, [1,2,3])
        array([10, 20, 40])

        Note that the dtype of the second argument may change the dtype of the
        result and can lead to unexpected results in some cases (see
        :ref:`Casting Rules <ufuncs.casting>`):

        >>> a = np.left_shift(np.uint8(255), np.int64(1))  # Expect 254
        >>> print(a, type(a)) # Unexpected result due to upcasting
        510 <class 'numpy.int64'>
        >>> b = np.left_shift(np.uint8(255), np.uint8(1))
        >>> print(b, type(b))
        254 <class 'numpy.uint8'>

        The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on
        ndarrays.

        >>> x1 = 5
        >>> x2 = np.array([1, 2, 3])
        >>> x1 << x2
        array([10, 20, 40])

    less = <ufunc 'less'>
        less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the truth value of (x1 < x2) element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array, element-wise comparison of `x1` and `x2`.
            Typically of type bool, unless ``dtype=object`` is passed.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        greater, less_equal, greater_equal, equal, not_equal

        Examples
        --------
        >>> import numpy as np
        >>> np.less([1, 2], [2, 2])
        array([ True, False])

        The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays.

        >>> a = np.array([1, 2])
        >>> b = np.array([2, 2])
        >>> a < b
        array([ True, False])

    less_equal = <ufunc 'less_equal'>
        less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the truth value of (x1 <= x2) element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array, element-wise comparison of `x1` and `x2`.
            Typically of type bool, unless ``dtype=object`` is passed.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        greater, less, greater_equal, equal, not_equal

        Examples
        --------
        >>> import numpy as np
        >>> np.less_equal([4, 2, 1], [2, 2, 2])
        array([False,  True,  True])

        The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on
        ndarrays.

        >>> a = np.array([4, 2, 1])
        >>> b = np.array([2, 2, 2])
        >>> a <= b
        array([False,  True,  True])

    little_endian = True
    log = <ufunc 'log'>
        log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Natural logarithm, element-wise.

        The natural logarithm `log` is the inverse of the exponential function,
        so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
        `e`.

        Parameters
        ----------
        x : array_like
            Input value.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The natural logarithm of `x`, element-wise.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        log10, log2, log1p, emath.log

        Notes
        -----
        Logarithm is a multivalued function: for each `x` there is an infinite
        number of `z` such that `exp(z) = x`. The convention is to return the
        `z` whose imaginary part lies in `(-pi, pi]`.

        For real-valued input data types, `log` always returns real output. For
        each value that cannot be expressed as a real number or infinity, it
        yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `log` is a complex analytical function that
        has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
        handles the floating-point negative zero as an infinitesimal negative
        number, conforming to the C99 standard.

        In the cases where the input has a negative real part and a very small
        negative complex part (approaching 0), the result is so close to `-pi`
        that it evaluates to exactly `-pi`.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 67.
               https://personal.math.ubc.ca/~cbm/aands/page_67.htm
        .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm

        Examples
        --------
        >>> import numpy as np
        >>> np.log([1, np.e, np.e**2, 0])
        array([  0.,   1.,   2., -inf])

    log10 = <ufunc 'log10'>
        log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the base 10 logarithm of the input array, element-wise.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The logarithm to the base 10 of `x`, element-wise. NaNs are
            returned where x is negative.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        emath.log10

        Notes
        -----
        Logarithm is a multivalued function: for each `x` there is an infinite
        number of `z` such that `10**z = x`. The convention is to return the
        `z` whose imaginary part lies in `(-pi, pi]`.

        For real-valued input data types, `log10` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `log10` is a complex analytical function that
        has a branch cut `[-inf, 0]` and is continuous from above on it.
        `log10` handles the floating-point negative zero as an infinitesimal
        negative number, conforming to the C99 standard.

        In the cases where the input has a negative real part and a very small
        negative complex part (approaching 0), the result is so close to `-pi`
        that it evaluates to exactly `-pi`.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 67.
               https://personal.math.ubc.ca/~cbm/aands/page_67.htm
        .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm

        Examples
        --------
        >>> import numpy as np
        >>> np.log10([1e-15, -3.])
        array([-15.,  nan])

    log1p = <ufunc 'log1p'>
        log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the natural logarithm of one plus the input array, element-wise.

        Calculates ``log(1 + x)``.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            Natural logarithm of `1 + x`, element-wise.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        expm1 : ``exp(x) - 1``, the inverse of `log1p`.

        Notes
        -----
        For real-valued input, `log1p` is accurate also for `x` so small
        that `1 + x == 1` in floating-point accuracy.

        Logarithm is a multivalued function: for each `x` there is an infinite
        number of `z` such that `exp(z) = 1 + x`. The convention is to return
        the `z` whose imaginary part lies in `[-pi, pi]`.

        For real-valued input data types, `log1p` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `log1p` is a complex analytical function that
        has a branch cut `[-inf, -1]` and is continuous from above on it.
        `log1p` handles the floating-point negative zero as an infinitesimal
        negative number, conforming to the C99 standard.

        References
        ----------
        .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
               10th printing, 1964, pp. 67.
               https://personal.math.ubc.ca/~cbm/aands/page_67.htm
        .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm

        Examples
        --------
        >>> import numpy as np
        >>> np.log1p(1e-99)
        1e-99
        >>> np.log(1 + 1e-99)
        0.0

    log2 = <ufunc 'log2'>
        log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Base-2 logarithm of `x`.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            Base-2 logarithm of `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        log, log10, log1p, emath.log2

        Notes
        -----
        .. versionadded:: 1.3.0

        Logarithm is a multivalued function: for each `x` there is an infinite
        number of `z` such that `2**z = x`. The convention is to return the `z`
        whose imaginary part lies in `(-pi, pi]`.

        For real-valued input data types, `log2` always returns real output.
        For each value that cannot be expressed as a real number or infinity,
        it yields ``nan`` and sets the `invalid` floating point error flag.

        For complex-valued input, `log2` is a complex analytical function that
        has a branch cut `[-inf, 0]` and is continuous from above on it. `log2`
        handles the floating-point negative zero as an infinitesimal negative
        number, conforming to the C99 standard.

        In the cases where the input has a negative real part and a very small
        negative complex part (approaching 0), the result is so close to `-pi`
        that it evaluates to exactly `-pi`.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.array([0, 1, 2, 2**4])
        >>> np.log2(x)
        array([-inf,   0.,   1.,   4.])

        >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
        >>> np.log2(xi)
        array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])

    logaddexp = <ufunc 'logaddexp'>
        logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Logarithm of the sum of exponentiations of the inputs.

        Calculates ``log(exp(x1) + exp(x2))``. This function is useful in
        statistics where the calculated probabilities of events may be so small
        as to exceed the range of normal floating point numbers.  In such cases
        the logarithm of the calculated probability is stored. This function
        allows adding probabilities stored in such a fashion.

        Parameters
        ----------
        x1, x2 : array_like
            Input values.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        result : ndarray
            Logarithm of ``exp(x1) + exp(x2)``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.

        Notes
        -----
        .. versionadded:: 1.3.0

        Examples
        --------
        >>> import numpy as np
        >>> prob1 = np.log(1e-50)
        >>> prob2 = np.log(2.5e-50)
        >>> prob12 = np.logaddexp(prob1, prob2)
        >>> prob12
        -113.87649168120691
        >>> np.exp(prob12)
        3.5000000000000057e-50

    logaddexp2 = <ufunc 'logaddexp2'>
        logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Logarithm of the sum of exponentiations of the inputs in base-2.

        Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine
        learning when the calculated probabilities of events may be so small as
        to exceed the range of normal floating point numbers.  In such cases
        the base-2 logarithm of the calculated probability can be used instead.
        This function allows adding probabilities stored in such a fashion.

        Parameters
        ----------
        x1, x2 : array_like
            Input values.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        result : ndarray
            Base-2 logarithm of ``2**x1 + 2**x2``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logaddexp: Logarithm of the sum of exponentiations of the inputs.

        Notes
        -----
        .. versionadded:: 1.3.0

        Examples
        --------
        >>> import numpy as np
        >>> prob1 = np.log2(1e-50)
        >>> prob2 = np.log2(2.5e-50)
        >>> prob12 = np.logaddexp2(prob1, prob2)
        >>> prob1, prob2, prob12
        (-166.09640474436813, -164.77447664948076, -164.28904982231052)
        >>> 2**prob12
        3.4999999999999914e-50

    logical_and = <ufunc 'logical_and'>
        logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the truth value of x1 AND x2 element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or bool
            Boolean result of the logical AND operation applied to the elements
            of `x1` and `x2`; the shape is determined by broadcasting.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logical_or, logical_not, logical_xor
        bitwise_and

        Examples
        --------
        >>> import numpy as np
        >>> np.logical_and(True, False)
        False
        >>> np.logical_and([True, False], [False, False])
        array([False, False])

        >>> x = np.arange(5)
        >>> np.logical_and(x>1, x<4)
        array([False, False,  True,  True, False])


        The ``&`` operator can be used as a shorthand for ``np.logical_and`` on
        boolean ndarrays.

        >>> a = np.array([True, False])
        >>> b = np.array([False, False])
        >>> a & b
        array([False, False])

    logical_not = <ufunc 'logical_not'>
        logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the truth value of NOT x element-wise.

        Parameters
        ----------
        x : array_like
            Logical NOT is applied to the elements of `x`.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : bool or ndarray of bool
            Boolean result with the same shape as `x` of the NOT operation
            on elements of `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        logical_and, logical_or, logical_xor

        Examples
        --------
        >>> import numpy as np
        >>> np.logical_not(3)
        False
        >>> np.logical_not([True, False, 0, 1])
        array([False,  True,  True, False])

        >>> x = np.arange(5)
        >>> np.logical_not(x<3)
        array([False, False, False,  True,  True])

    logical_or = <ufunc 'logical_or'>
        logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the truth value of x1 OR x2 element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Logical OR is applied to the elements of `x1` and `x2`.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or bool
            Boolean result of the logical OR operation applied to the elements
            of `x1` and `x2`; the shape is determined by broadcasting.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logical_and, logical_not, logical_xor
        bitwise_or

        Examples
        --------
        >>> import numpy as np
        >>> np.logical_or(True, False)
        True
        >>> np.logical_or([True, False], [False, False])
        array([ True, False])

        >>> x = np.arange(5)
        >>> np.logical_or(x < 1, x > 3)
        array([ True, False, False, False,  True])

        The ``|`` operator can be used as a shorthand for ``np.logical_or`` on
        boolean ndarrays.

        >>> a = np.array([True, False])
        >>> b = np.array([False, False])
        >>> a | b
        array([ True, False])

    logical_xor = <ufunc 'logical_xor'>
        logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute the truth value of x1 XOR x2, element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Logical XOR is applied to the elements of `x1` and `x2`.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : bool or ndarray of bool
            Boolean result of the logical XOR operation applied to the elements
            of `x1` and `x2`; the shape is determined by broadcasting.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        logical_and, logical_or, logical_not, bitwise_xor

        Examples
        --------
        >>> import numpy as np
        >>> np.logical_xor(True, False)
        True
        >>> np.logical_xor([True, True, False, False], [True, False, True, False])
        array([False,  True,  True, False])

        >>> x = np.arange(5)
        >>> np.logical_xor(x < 1, x > 3)
        array([ True, False, False, False,  True])

        Simple example showing support of broadcasting

        >>> np.logical_xor(0, np.eye(2))
        array([[ True, False],
               [False,  True]])

    matmul = <ufunc 'matmul'>
        matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, axes, axis])

        Matrix product of two arrays.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays, scalars not allowed.
        out : ndarray, optional
            A location into which the result is stored. If provided, it must have
            a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not
            provided or None, a freshly-allocated array is returned.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

            .. versionadded:: 1.16
               Now handles ufunc kwargs

        Returns
        -------
        y : ndarray
            The matrix product of the inputs.
            This is a scalar only when both x1, x2 are 1-d vectors.

        Raises
        ------
        ValueError
            If the last dimension of `x1` is not the same size as
            the second-to-last dimension of `x2`.

            If a scalar value is passed in.

        See Also
        --------
        vdot : Complex-conjugating dot product.
        tensordot : Sum products over arbitrary axes.
        einsum : Einstein summation convention.
        dot : alternative matrix product with different broadcasting rules.

        Notes
        -----

        The behavior depends on the arguments in the following way.

        - If both arguments are 2-D they are multiplied like conventional
          matrices.
        - If either argument is N-D, N > 2, it is treated as a stack of
          matrices residing in the last two indexes and broadcast accordingly.
        - If the first argument is 1-D, it is promoted to a matrix by
          prepending a 1 to its dimensions. After matrix multiplication
          the prepended 1 is removed.
        - If the second argument is 1-D, it is promoted to a matrix by
          appending a 1 to its dimensions. After matrix multiplication
          the appended 1 is removed.

        ``matmul`` differs from ``dot`` in two important ways:

        - Multiplication by scalars is not allowed, use ``*`` instead.
        - Stacks of matrices are broadcast together as if the matrices
          were elements, respecting the signature ``(n,k),(k,m)->(n,m)``:

          >>> a = np.ones([9, 5, 7, 4])
          >>> c = np.ones([9, 5, 4, 3])
          >>> np.dot(a, c).shape
          (9, 5, 7, 9, 5, 3)
          >>> np.matmul(a, c).shape
          (9, 5, 7, 3)
          >>> # n is 7, k is 4, m is 3

        The matmul function implements the semantics of the ``@`` operator
        introduced in Python 3.5 following :pep:`465`.

        It uses an optimized BLAS library when possible (see `numpy.linalg`).

        Examples
        --------
        For 2-D arrays it is the matrix product:

        >>> import numpy as np

        >>> a = np.array([[1, 0],
        ...               [0, 1]])
        >>> b = np.array([[4, 1],
        ...               [2, 2]])
        >>> np.matmul(a, b)
        array([[4, 1],
               [2, 2]])

        For 2-D mixed with 1-D, the result is the usual.

        >>> a = np.array([[1, 0],
        ...               [0, 1]])
        >>> b = np.array([1, 2])
        >>> np.matmul(a, b)
        array([1, 2])
        >>> np.matmul(b, a)
        array([1, 2])


        Broadcasting is conventional for stacks of arrays

        >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
        >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
        >>> np.matmul(a,b).shape
        (2, 2, 2)
        >>> np.matmul(a, b)[0, 1, 1]
        98
        >>> sum(a[0, 1, :] * b[0 , :, 1])
        98

        Vector, vector returns the scalar inner product, but neither argument
        is complex-conjugated:

        >>> np.matmul([2j, 3j], [2j, 3j])
        (-13+0j)

        Scalar multiplication raises an error.

        >>> np.matmul([1,2], 3)
        Traceback (most recent call last):
        ...
        ValueError: matmul: Input operand 1 does not have enough dimensions ...

        The ``@`` operator can be used as a shorthand for ``np.matmul`` on
        ndarrays.

        >>> x1 = np.array([2j, 3j])
        >>> x2 = np.array([2j, 3j])
        >>> x1 @ x2
        (-13+0j)

        .. versionadded:: 1.10.0

    maximum = <ufunc 'maximum'>
        maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Element-wise maximum of array elements.

        Compare two arrays and return a new array containing the element-wise
        maxima. If one of the elements being compared is a NaN, then that
        element is returned. If both elements are NaNs then the first is
        returned. The latter distinction is important for complex NaNs, which
        are defined as at least one of the real or imaginary parts being a NaN.
        The net effect is that NaNs are propagated.

        Parameters
        ----------
        x1, x2 : array_like
            The arrays holding the elements to be compared.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The maximum of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        minimum :
            Element-wise minimum of two arrays, propagates NaNs.
        fmax :
            Element-wise maximum of two arrays, ignores NaNs.
        amax :
            The maximum value of an array along a given axis, propagates NaNs.
        nanmax :
            The maximum value of an array along a given axis, ignores NaNs.

        fmin, amin, nanmin

        Notes
        -----
        The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when
        neither x1 nor x2 are nans, but it is faster and does proper
        broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.maximum([2, 3, 4], [1, 5, 2])
        array([2, 5, 4])

        >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
        array([[ 1. ,  2. ],
               [ 0.5,  2. ]])

        >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])
        array([nan, nan, nan])
        >>> np.maximum(np.inf, 1)
        inf

    mgrid = <numpy.lib._index_tricks_impl.MGridClass object>
    minimum = <ufunc 'minimum'>
        minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Element-wise minimum of array elements.

        Compare two arrays and return a new array containing the element-wise
        minima. If one of the elements being compared is a NaN, then that
        element is returned. If both elements are NaNs then the first is
        returned. The latter distinction is important for complex NaNs, which
        are defined as at least one of the real or imaginary parts being a NaN.
        The net effect is that NaNs are propagated.

        Parameters
        ----------
        x1, x2 : array_like
            The arrays holding the elements to be compared.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The minimum of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        maximum :
            Element-wise maximum of two arrays, propagates NaNs.
        fmin :
            Element-wise minimum of two arrays, ignores NaNs.
        amin :
            The minimum value of an array along a given axis, propagates NaNs.
        nanmin :
            The minimum value of an array along a given axis, ignores NaNs.

        fmax, amax, nanmax

        Notes
        -----
        The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when
        neither x1 nor x2 are NaNs, but it is faster and does proper
        broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.minimum([2, 3, 4], [1, 5, 2])
        array([1, 3, 2])

        >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting
        array([[ 0.5,  0. ],
               [ 0. ,  1. ]])

        >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])
        array([nan, nan, nan])
        >>> np.minimum(-np.inf, 1)
        -inf

    mod = <ufunc 'remainder'>
        remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns the element-wise remainder of division.

        Computes the remainder complementary to the `floor_divide` function.  It is
        equivalent to the Python modulus operator ``x1 % x2`` and has the same sign
        as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
        is ``mod``.

        .. warning::

            This should not be confused with:

            * Python 3.7's `math.remainder` and C's ``remainder``, which
              computes the IEEE remainder, which are the complement to
              ``round(x1 / x2)``.
            * The MATLAB ``rem`` function and or the C ``%`` operator which is the
              complement to ``int(x1 / x2)``.

        Parameters
        ----------
        x1 : array_like
            Dividend array.
        x2 : array_like
            Divisor array.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        floor_divide : Equivalent of Python ``//`` operator.
        divmod : Simultaneous floor division and remainder.
        fmod : Equivalent of the MATLAB ``rem`` function.
        divide, floor

        Notes
        -----
        Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
        integers.
        ``mod`` is an alias of ``remainder``.

        Examples
        --------
        >>> import numpy as np
        >>> np.remainder([4, 7], [2, 3])
        array([0, 1])
        >>> np.remainder(np.arange(7), 5)
        array([0, 1, 2, 3, 4, 0, 1])

        The ``%`` operator can be used as a shorthand for ``np.remainder`` on
        ndarrays.

        >>> x1 = np.arange(7)
        >>> x1 % 5
        array([0, 1, 2, 3, 4, 0, 1])

    modf = <ufunc 'modf'>
        modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the fractional and integral parts of an array, element-wise.

        The fractional and integral parts are negative if the given number is
        negative.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y1 : ndarray
            Fractional part of `x`.
            This is a scalar if `x` is a scalar.
        y2 : ndarray
            Integral part of `x`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        For integer input the return values are floats.

        See Also
        --------
        divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
                 switched, except it always has a positive remainder.

        Examples
        --------
        >>> import numpy as np
        >>> np.modf([0, 3.5])
        (array([ 0. ,  0.5]), array([ 0.,  3.]))
        >>> np.modf(-0.5)
        (-0.5, -0)

    multiply = <ufunc 'multiply'>
        multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Multiply arguments element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays to be multiplied.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The product of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        Notes
        -----
        Equivalent to `x1` * `x2` in terms of array broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.multiply(2.0, 4.0)
        8.0

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> np.multiply(x1, x2)
        array([[  0.,   1.,   4.],
               [  0.,   4.,  10.],
               [  0.,   7.,  16.]])

        The ``*`` operator can be used as a shorthand for ``np.multiply`` on
        ndarrays.

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> x1 * x2
        array([[  0.,   1.,   4.],
               [  0.,   4.,  10.],
               [  0.,   7.,  16.]])

    nan = nan
    negative = <ufunc 'negative'>
        negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Numerical negative, element-wise.

        Parameters
        ----------
        x : array_like or scalar
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            Returned array or scalar: `y = -x`.
            This is a scalar if `x` is a scalar.

        Examples
        --------
        >>> import numpy as np
        >>> np.negative([1.,-1.])
        array([-1.,  1.])

        The unary ``-`` operator can be used as a shorthand for ``np.negative`` on
        ndarrays.

        >>> x1 = np.array(([1., -1.]))
        >>> -x1
        array([-1.,  1.])

    newaxis = None
    nextafter = <ufunc 'nextafter'>
        nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the next floating-point value after x1 towards x2, element-wise.

        Parameters
        ----------
        x1 : array_like
            Values to find the next representable value of.
        x2 : array_like
            The direction where to look for the next representable value of `x1`.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            The next representable values of `x1` in the direction of `x2`.
            This is a scalar if both `x1` and `x2` are scalars.

        Examples
        --------
        >>> import numpy as np
        >>> eps = np.finfo(np.float64).eps
        >>> np.nextafter(1, 2) == eps + 1
        True
        >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
        array([ True,  True])

    not_equal = <ufunc 'not_equal'>
        not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return (x1 != x2) element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array, element-wise comparison of `x1` and `x2`.
            Typically of type bool, unless ``dtype=object`` is passed.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        equal, greater, greater_equal, less, less_equal

        Examples
        --------
        >>> import numpy as np
        >>> np.not_equal([1.,2.], [1., 3.])
        array([False,  True])
        >>> np.not_equal([1, 2], [[1, 3],[1, 4]])
        array([[False,  True],
               [False,  True]])

        The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on
        ndarrays.

        >>> a = np.array([1., 2.])
        >>> b = np.array([1., 3.])
        >>> a != b
        array([False,  True])

    ogrid = <numpy.lib._index_tricks_impl.OGridClass object>
    pi = 3.141592653589793
    positive = <ufunc 'positive'>
        positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Numerical positive, element-wise.

        .. versionadded:: 1.13.0

        Parameters
        ----------
        x : array_like or scalar
            Input array.

        Returns
        -------
        y : ndarray or scalar
            Returned array or scalar: `y = +x`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        Equivalent to `x.copy()`, but only defined for types that support
        arithmetic.

        Examples
        --------
        >>> import numpy as np

        >>> x1 = np.array(([1., -1.]))
        >>> np.positive(x1)
        array([ 1., -1.])

        The unary ``+`` operator can be used as a shorthand for ``np.positive`` on
        ndarrays.

        >>> x1 = np.array(([1., -1.]))
        >>> +x1
        array([ 1., -1.])

    pow = <ufunc 'power'>
        power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        First array elements raised to powers from second array, element-wise.

        Raise each base in `x1` to the positionally-corresponding power in
        `x2`.  `x1` and `x2` must be broadcastable to the same shape.

        An integer type raised to a negative integer power will raise a
        ``ValueError``.

        Negative values raised to a non-integral value will return ``nan``.
        To get complex results, cast the input to complex, or specify the
        ``dtype`` to be ``complex`` (see the example below).

        Parameters
        ----------
        x1 : array_like
            The bases.
        x2 : array_like
            The exponents.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The bases in `x1` raised to the exponents in `x2`.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        float_power : power function that promotes integers to float

        Examples
        --------
        >>> import numpy as np

        Cube each element in an array.

        >>> x1 = np.arange(6)
        >>> x1
        [0, 1, 2, 3, 4, 5]
        >>> np.power(x1, 3)
        array([  0,   1,   8,  27,  64, 125])

        Raise the bases to different exponents.

        >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
        >>> np.power(x1, x2)
        array([  0.,   1.,   8.,  27.,  16.,   5.])

        The effect of broadcasting.

        >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
        >>> x2
        array([[1, 2, 3, 3, 2, 1],
               [1, 2, 3, 3, 2, 1]])
        >>> np.power(x1, x2)
        array([[ 0,  1,  8, 27, 16,  5],
               [ 0,  1,  8, 27, 16,  5]])

        The ``**`` operator can be used as a shorthand for ``np.power`` on
        ndarrays.

        >>> x2 = np.array([1, 2, 3, 3, 2, 1])
        >>> x1 = np.arange(6)
        >>> x1 ** x2
        array([ 0,  1,  8, 27, 16,  5])

        Negative values raised to a non-integral value will result in ``nan``
        (and a warning will be generated).

        >>> x3 = np.array([-1.0, -4.0])
        >>> with np.errstate(invalid='ignore'):
        ...     p = np.power(x3, 1.5)
        ...
        >>> p
        array([nan, nan])

        To get complex results, give the argument ``dtype=complex``.

        >>> np.power(x3, 1.5, dtype=complex)
        array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

    power = <ufunc 'power'>
        power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        First array elements raised to powers from second array, element-wise.

        Raise each base in `x1` to the positionally-corresponding power in
        `x2`.  `x1` and `x2` must be broadcastable to the same shape.

        An integer type raised to a negative integer power will raise a
        ``ValueError``.

        Negative values raised to a non-integral value will return ``nan``.
        To get complex results, cast the input to complex, or specify the
        ``dtype`` to be ``complex`` (see the example below).

        Parameters
        ----------
        x1 : array_like
            The bases.
        x2 : array_like
            The exponents.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The bases in `x1` raised to the exponents in `x2`.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        float_power : power function that promotes integers to float

        Examples
        --------
        >>> import numpy as np

        Cube each element in an array.

        >>> x1 = np.arange(6)
        >>> x1
        [0, 1, 2, 3, 4, 5]
        >>> np.power(x1, 3)
        array([  0,   1,   8,  27,  64, 125])

        Raise the bases to different exponents.

        >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
        >>> np.power(x1, x2)
        array([  0.,   1.,   8.,  27.,  16.,   5.])

        The effect of broadcasting.

        >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
        >>> x2
        array([[1, 2, 3, 3, 2, 1],
               [1, 2, 3, 3, 2, 1]])
        >>> np.power(x1, x2)
        array([[ 0,  1,  8, 27, 16,  5],
               [ 0,  1,  8, 27, 16,  5]])

        The ``**`` operator can be used as a shorthand for ``np.power`` on
        ndarrays.

        >>> x2 = np.array([1, 2, 3, 3, 2, 1])
        >>> x1 = np.arange(6)
        >>> x1 ** x2
        array([ 0,  1,  8, 27, 16,  5])

        Negative values raised to a non-integral value will result in ``nan``
        (and a warning will be generated).

        >>> x3 = np.array([-1.0, -4.0])
        >>> with np.errstate(invalid='ignore'):
        ...     p = np.power(x3, 1.5)
        ...
        >>> p
        array([nan, nan])

        To get complex results, give the argument ``dtype=complex``.

        >>> np.power(x3, 1.5, dtype=complex)
        array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

    r_ = <numpy.lib._index_tricks_impl.RClass object>
    rad2deg = <ufunc 'rad2deg'>
        rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Convert angles from radians to degrees.

        Parameters
        ----------
        x : array_like
            Angle in radians.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding angle in degrees.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        deg2rad : Convert angles from degrees to radians.
        unwrap : Remove large jumps in angle by wrapping.

        Notes
        -----
        .. versionadded:: 1.3.0

        rad2deg(x) is ``180 * x / pi``.

        Examples
        --------
        >>> import numpy as np
        >>> np.rad2deg(np.pi/2)
        90.0

    radians = <ufunc 'radians'>
        radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Convert angles from degrees to radians.

        Parameters
        ----------
        x : array_like
            Input array in degrees.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding radian values.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        deg2rad : equivalent function

        Examples
        --------
        >>> import numpy as np

        Convert a degree array to radians

        >>> deg = np.arange(12.) * 30.
        >>> np.radians(deg)
        array([ 0.        ,  0.52359878,  1.04719755,  1.57079633,  2.0943951 ,
                2.61799388,  3.14159265,  3.66519143,  4.1887902 ,  4.71238898,
                5.23598776,  5.75958653])

        >>> out = np.zeros((deg.shape))
        >>> ret = np.radians(deg, out)
        >>> ret is out
        True

    reciprocal = <ufunc 'reciprocal'>
        reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the reciprocal of the argument, element-wise.

        Calculates ``1/x``.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            Return array.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        .. note::
            This function is not designed to work with integers.

        For integer arguments with absolute value larger than 1 the result is
        always zero because of the way Python handles integer division.  For
        integer zero the result is an overflow.

        Examples
        --------
        >>> import numpy as np
        >>> np.reciprocal(2.)
        0.5
        >>> np.reciprocal([1, 2., 3.33])
        array([ 1.       ,  0.5      ,  0.3003003])

    remainder = <ufunc 'remainder'>
        remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns the element-wise remainder of division.

        Computes the remainder complementary to the `floor_divide` function.  It is
        equivalent to the Python modulus operator ``x1 % x2`` and has the same sign
        as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
        is ``mod``.

        .. warning::

            This should not be confused with:

            * Python 3.7's `math.remainder` and C's ``remainder``, which
              computes the IEEE remainder, which are the complement to
              ``round(x1 / x2)``.
            * The MATLAB ``rem`` function and or the C ``%`` operator which is the
              complement to ``int(x1 / x2)``.

        Parameters
        ----------
        x1 : array_like
            Dividend array.
        x2 : array_like
            Divisor array.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        floor_divide : Equivalent of Python ``//`` operator.
        divmod : Simultaneous floor division and remainder.
        fmod : Equivalent of the MATLAB ``rem`` function.
        divide, floor

        Notes
        -----
        Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
        integers.
        ``mod`` is an alias of ``remainder``.

        Examples
        --------
        >>> import numpy as np
        >>> np.remainder([4, 7], [2, 3])
        array([0, 1])
        >>> np.remainder(np.arange(7), 5)
        array([0, 1, 2, 3, 4, 0, 1])

        The ``%`` operator can be used as a shorthand for ``np.remainder`` on
        ndarrays.

        >>> x1 = np.arange(7)
        >>> x1 % 5
        array([0, 1, 2, 3, 4, 0, 1])

    right_shift = <ufunc 'right_shift'>
        right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Shift the bits of an integer to the right.

        Bits are shifted to the right `x2`.  Because the internal
        representation of numbers is in binary format, this operation is
        equivalent to dividing `x1` by ``2**x2``.

        Parameters
        ----------
        x1 : array_like, int
            Input values.
        x2 : array_like, int
            Number of bits to remove at the right of `x1`.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray, int
            Return `x1` with bits shifted `x2` times to the right.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        left_shift : Shift the bits of an integer to the left.
        binary_repr : Return the binary representation of the input number
            as a string.

        Examples
        --------
        >>> import numpy as np
        >>> np.binary_repr(10)
        '1010'
        >>> np.right_shift(10, 1)
        5
        >>> np.binary_repr(5)
        '101'

        >>> np.right_shift(10, [1,2,3])
        array([5, 2, 1])

        The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on
        ndarrays.

        >>> x1 = 10
        >>> x2 = np.array([1,2,3])
        >>> x1 >> x2
        array([5, 2, 1])

    rint = <ufunc 'rint'>
        rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Round elements of the array to the nearest integer.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Output array is same shape and type as `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        fix, ceil, floor, trunc

        Notes
        -----
        For values exactly halfway between rounded decimal values, NumPy
        rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
        -0.5 and 0.5 round to 0.0, etc.

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
        >>> np.rint(a)
        array([-2., -2., -0.,  0.,  2.,  2.,  2.])

    s_ = <numpy.lib._index_tricks_impl.IndexExpression object>
    sctypeDict = {'a': <class 'numpy.bytes_'>, 'bool': <class 'numpy.bool'...
    sign = <ufunc 'sign'>
        sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns an element-wise indication of the sign of a number.

        The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``.  nan
        is returned for nan inputs.

        For complex inputs, the `sign` function returns ``x / abs(x)``, the
        generalization of the above (and ``0 if x==0``).

        .. versionchanged:: 2.0.0
            Definition of complex sign changed to follow the Array API standard.

        Parameters
        ----------
        x : array_like
            Input values.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The sign of `x`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        There is more than one definition of sign in common use for complex
        numbers.  The definition used here, :math:`x/|x|`, is the more common
        and useful one, but is different from the one used in numpy prior to
        version 2.0, :math:`x/\sqrt{x*x}`, which is equivalent to
        ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``.

        Examples
        --------
        >>> import numpy as np
        >>> np.sign([-5., 4.5])
        array([-1.,  1.])
        >>> np.sign(0)
        0
        >>> np.sign([3-4j, 8j])
        array([0.6-0.8j, 0. +1.j ])

    signbit = <ufunc 'signbit'>
        signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Returns element-wise True where signbit is set (less than zero).

        Parameters
        ----------
        x : array_like
            The input value(s).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        result : ndarray of bool
            Output array, or reference to `out` if that was supplied.
            This is a scalar if `x` is a scalar.

        Examples
        --------
        >>> import numpy as np
        >>> np.signbit(-1.2)
        True
        >>> np.signbit(np.array([1, -2.3, 2.1]))
        array([False,  True, False])

    sin = <ufunc 'sin'>
        sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Trigonometric sine, element-wise.

        Parameters
        ----------
        x : array_like
            Angle, in radians (:math:`2 \pi` rad equals 360 degrees).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : array_like
            The sine of each element of x.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        arcsin, sinh, cos

        Notes
        -----
        The sine is one of the fundamental functions of trigonometry (the
        mathematical study of triangles).  Consider a circle of radius 1
        centered on the origin.  A ray comes in from the :math:`+x` axis, makes
        an angle at the origin (measured counter-clockwise from that axis), and
        departs from the origin.  The :math:`y` coordinate of the outgoing
        ray's intersection with the unit circle is the sine of that angle.  It
        ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.`  The
        function has zeroes where the angle is a multiple of :math:`\pi`.
        Sines of angles between :math:`\pi` and :math:`2\pi` are negative.
        The numerous properties of the sine and related functions are included
        in any standard trigonometry text.

        Examples
        --------
        >>> import numpy as np

        Print sine of one angle:

        >>> np.sin(np.pi/2.)
        1.0

        Print sines of an array of angles given in degrees:

        >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )
        array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])

        Plot the sine function:

        >>> import matplotlib.pylab as plt
        >>> x = np.linspace(-np.pi, np.pi, 201)
        >>> plt.plot(x, np.sin(x))
        >>> plt.xlabel('Angle [rad]')
        >>> plt.ylabel('sin(x)')
        >>> plt.axis('tight')
        >>> plt.show()

    sinh = <ufunc 'sinh'>
        sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Hyperbolic sine, element-wise.

        Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or
        ``-1j * np.sin(1j*x)``.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding hyperbolic sine values.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        If `out` is provided, the function writes the result into it,
        and returns a reference to `out`.  (See Examples)

        References
        ----------
        M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
        New York, NY: Dover, 1972, pg. 83.

        Examples
        --------
        >>> import numpy as np
        >>> np.sinh(0)
        0.0
        >>> np.sinh(np.pi*1j/2)
        1j
        >>> np.sinh(np.pi*1j) # (exact value is 0)
        1.2246063538223773e-016j
        >>> # Discrepancy due to vagaries of floating point arithmetic.

        >>> # Example of providing the optional output parameter
        >>> out1 = np.array([0], dtype='d')
        >>> out2 = np.sinh([0.1], out1)
        >>> out2 is out1
        True

        >>> # Example of ValueError due to provision of shape mis-matched `out`
        >>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

    spacing = <ufunc 'spacing'>
        spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the distance between x and the nearest adjacent number.

        Parameters
        ----------
        x : array_like
            Values to find the spacing of.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            The spacing of values of `x`.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        It can be considered as a generalization of EPS:
        ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there
        should not be any representable number between ``x + spacing(x)`` and
        x for any finite x.

        Spacing of +- inf and NaN is NaN.

        Examples
        --------
        >>> import numpy as np
        >>> np.spacing(1) == np.finfo(np.float64).eps
        True

    sqrt = <ufunc 'sqrt'>
        sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the non-negative square-root of an array, element-wise.

        Parameters
        ----------
        x : array_like
            The values whose square-roots are required.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            An array of the same shape as `x`, containing the positive
            square-root of each element in `x`.  If any element in `x` is
            complex, a complex array is returned (and the square-roots of
            negative reals are calculated).  If all of the elements in `x`
            are real, so is `y`, with negative elements returning ``nan``.
            If `out` was provided, `y` is a reference to it.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        emath.sqrt
            A version which returns complex numbers when given negative reals.
            Note that 0.0 and -0.0 are handled differently for complex inputs.

        Notes
        -----
        *sqrt* has--consistent with common convention--as its branch cut the
        real "interval" [`-inf`, 0), and is continuous from above on it.
        A branch cut is a curve in the complex plane across which a given
        complex function fails to be continuous.

        Examples
        --------
        >>> import numpy as np
        >>> np.sqrt([1,4,9])
        array([ 1.,  2.,  3.])

        >>> np.sqrt([4, -1, -3+4J])
        array([ 2.+0.j,  0.+1.j,  1.+2.j])

        >>> np.sqrt([4, -1, np.inf])
        array([ 2., nan, inf])

    square = <ufunc 'square'>
        square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the element-wise square of the input.

        Parameters
        ----------
        x : array_like
            Input data.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        out : ndarray or scalar
            Element-wise `x*x`, of the same shape and dtype as `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        numpy.linalg.matrix_power
        sqrt
        power

        Examples
        --------
        >>> import numpy as np
        >>> np.square([-1j, 1])
        array([-1.-0.j,  1.+0.j])

    subtract = <ufunc 'subtract'>
        subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Subtract arguments, element-wise.

        Parameters
        ----------
        x1, x2 : array_like
            The arrays to be subtracted from each other.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The difference of `x1` and `x2`, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        Notes
        -----
        Equivalent to ``x1 - x2`` in terms of array broadcasting.

        Examples
        --------
        >>> import numpy as np
        >>> np.subtract(1.0, 4.0)
        -3.0

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> np.subtract(x1, x2)
        array([[ 0.,  0.,  0.],
               [ 3.,  3.,  3.],
               [ 6.,  6.,  6.]])

        The ``-`` operator can be used as a shorthand for ``np.subtract`` on
        ndarrays.

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> x1 - x2
        array([[0., 0., 0.],
               [3., 3., 3.],
               [6., 6., 6.]])

    tan = <ufunc 'tan'>
        tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute tangent element-wise.

        Equivalent to ``np.sin(x)/np.cos(x)`` element-wise.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding tangent values.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        If `out` is provided, the function writes the result into it,
        and returns a reference to `out`.  (See Examples)

        References
        ----------
        M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
        New York, NY: Dover, 1972.

        Examples
        --------
        >>> import numpy as np
        >>> from math import pi
        >>> np.tan(np.array([-pi,pi/2,pi]))
        array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])
        >>>
        >>> # Example of providing the optional output parameter illustrating
        >>> # that what is returned is a reference to said parameter
        >>> out1 = np.array([0], dtype='d')
        >>> out2 = np.cos([0.1], out1)
        >>> out2 is out1
        True
        >>>
        >>> # Example of ValueError due to provision of shape mis-matched `out`
        >>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

    tanh = <ufunc 'tanh'>
        tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Compute hyperbolic tangent element-wise.

        Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``.

        Parameters
        ----------
        x : array_like
            Input array.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The corresponding hyperbolic tangent values.
            This is a scalar if `x` is a scalar.

        Notes
        -----
        If `out` is provided, the function writes the result into it,
        and returns a reference to `out`.  (See Examples)

        References
        ----------
        .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
               New York, NY: Dover, 1972, pg. 83.
               https://personal.math.ubc.ca/~cbm/aands/page_83.htm

        .. [2] Wikipedia, "Hyperbolic function",
               https://en.wikipedia.org/wiki/Hyperbolic_function

        Examples
        --------
        >>> import numpy as np
        >>> np.tanh((0, np.pi*1j, np.pi*1j/2))
        array([ 0. +0.00000000e+00j,  0. -1.22460635e-16j,  0. +1.63317787e+16j])

        >>> # Example of providing the optional output parameter illustrating
        >>> # that what is returned is a reference to said parameter
        >>> out1 = np.array([0], dtype='d')
        >>> out2 = np.tanh([0.1], out1)
        >>> out2 is out1
        True

        >>> # Example of ValueError due to provision of shape mis-matched `out`
        >>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

    test = <numpy._pytesttester.PytestTester object>
    true_divide = <ufunc 'divide'>
        divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Divide arguments element-wise.

        Parameters
        ----------
        x1 : array_like
            Dividend array.
        x2 : array_like
            Divisor array.
            If ``x1.shape != x2.shape``, they must be broadcastable to a common
            shape (which becomes the shape of the output).
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The quotient ``x1/x2``, element-wise.
            This is a scalar if both `x1` and `x2` are scalars.

        See Also
        --------
        seterr : Set whether to raise or warn on overflow, underflow and
                 division by zero.

        Notes
        -----
        Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting.

        The ``true_divide(x1, x2)`` function is an alias for
        ``divide(x1, x2)``.

        Examples
        --------
        >>> import numpy as np
        >>> np.divide(2.0, 4.0)
        0.5
        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = np.arange(3.0)
        >>> np.divide(x1, x2)
        array([[nan, 1. , 1. ],
               [inf, 4. , 2.5],
               [inf, 7. , 4. ]])

        The ``/`` operator can be used as a shorthand for ``np.divide`` on
        ndarrays.

        >>> x1 = np.arange(9.0).reshape((3, 3))
        >>> x2 = 2 * np.ones(3)
        >>> x1 / x2
        array([[0. , 0.5, 1. ],
               [1.5, 2. , 2.5],
               [3. , 3.5, 4. ]])

    trunc = <ufunc 'trunc'>
        trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

        Return the truncated value of the input, element-wise.

        The truncated value of the scalar `x` is the nearest integer `i` which
        is closer to zero than `x` is. In short, the fractional part of the
        signed number `x` is discarded.

        Parameters
        ----------
        x : array_like
            Input data.
        out : ndarray, None, or tuple of ndarray and None, optional
            A location into which the result is stored. If provided, it must have
            a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned. A tuple (possible only as a
            keyword argument) must have length equal to the number of outputs.
        where : array_like, optional
            This condition is broadcast over the input. At locations where the
            condition is True, the `out` array will be set to the ufunc result.
            Elsewhere, the `out` array will retain its original value.
            Note that if an uninitialized `out` array is created via the default
            ``out=None``, locations within it where the condition is False will
            remain uninitialized.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray or scalar
            The truncated value of each element in `x`.
            This is a scalar if `x` is a scalar.

        See Also
        --------
        ceil, floor, rint, fix

        Notes
        -----
        .. versionadded:: 1.3.0

        Examples
        --------
        >>> import numpy as np
        >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
        >>> np.trunc(a)
        array([-1., -1., -0.,  0.,  1.,  1.,  2.])

    typecodes = {'All': '?bhilqnpBHILQNPefdgFDGSUVOMm', 'AllFloat': 'efdgF...
    vecdot = <ufunc 'vecdot'>
        vecdot(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, axes, axis])

        Vector dot product of two arrays.

        Let :math:`\mathbf{a}` be a vector in `x1` and :math:`\mathbf{b}` be
        a corresponding vector in `x2`. The dot product is defined as:

        .. math::
           \mathbf{a} \cdot \mathbf{b} = \sum_{i=0}^{n-1} \overline{a_i}b_i

        where the sum is over the last dimension (unless `axis` is specified) and
        where :math:`\overline{a_i}` denotes the complex conjugate if :math:`a_i`
        is complex and the identity otherwise.

        Parameters
        ----------
        x1, x2 : array_like
            Input arrays, scalars not allowed.
        out : ndarray, optional
            A location into which the result is stored. If provided, it must have
            a shape that the broadcasted shape of `x1` and `x2` with the last axis
            removed. If not provided or None, a freshly-allocated array is used.
        **kwargs
            For other keyword-only arguments, see the
            :ref:`ufunc docs <ufuncs.kwargs>`.

        Returns
        -------
        y : ndarray
            The vector dot product of the inputs.
            This is a scalar only when both x1, x2 are 1-d vectors.

        Raises
        ------
        ValueError
            If the last dimension of `x1` is not the same size as
            the last dimension of `x2`.

            If a scalar value is passed in.

        See Also
        --------
        vdot : same but flattens arguments first
        einsum : Einstein summation convention.

        Examples
        --------
        >>> import numpy as np

        Get the projected size along a given normal for an array of vectors.

        >>> v = np.array([[0., 5., 0.], [0., 0., 10.], [0., 6., 8.]])
        >>> n = np.array([0., 0.6, 0.8])
        >>> np.vecdot(v, n)
        array([ 3.,  8., 10.])

        .. versionadded:: 2.0.0

VERSION
    2.1.3

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\numpy\__init__.py

Python Library Documentation: function write_index_binary in module faiss.swigfaiss

write_index_binary(*args)

Python Library Documentation: function omp_get_max_threads in module faiss.swigfaiss

omp_get_max_threads()

Python Library Documentation: function omp_set_num_threads in module faiss.swigfaiss

omp_set_num_threads(num_threads)

Error rendering doc: No Python documentation found for 'FAISS_OPT_LEVEL'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

Python Library Documentation: NoneType object

class NoneType(object)
 |  Methods defined here:
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.

Python Library Documentation: module os

NAME
    os - OS routines for NT or Posix depending on what system we're on.

MODULE REFERENCE
    https://docs.python.org/3.12/library/os.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This exports:
      - all functions from posix or nt, e.g. unlink, stat, etc.
      - os.path is either posixpath or ntpath
      - os.name is either 'posix' or 'nt'
      - os.curdir is a string representing the current directory (always '.')
      - os.pardir is a string representing the parent directory (always '..')
      - os.sep is the (or a most common) pathname separator ('/' or '\\')
      - os.extsep is the extension separator (always '.')
      - os.altsep is the alternate pathname separator (None or '/')
      - os.pathsep is the component separator used in $PATH etc
      - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
      - os.defpath is the default search path for executables
      - os.devnull is the file path of the null device ('/dev/null', etc.)

    Programs that import and use 'os' stand a better chance of being
    portable between different platforms.  Of course, they must then
    only use functions that are defined by all platforms (e.g., unlink
    and opendir), and leave all pathname manipulation to os.path
    (e.g., split and join).

CLASSES
    builtins.Exception(builtins.BaseException)
        builtins.OSError
    builtins.object
        nt.DirEntry
    builtins.tuple(builtins.object)
        nt.times_result
        nt.uname_result
        stat_result
        statvfs_result
        terminal_size

    class DirEntry(builtins.object)
     |  Methods defined here:
     |
     |  __fspath__(self, /)
     |      Returns the path for the entry.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  inode(self, /)
     |      Return inode of the entry; cached per entry.
     |
     |  is_dir(self, /, *, follow_symlinks=True)
     |      Return True if the entry is a directory; cached per entry.
     |
     |  is_file(self, /, *, follow_symlinks=True)
     |      Return True if the entry is a file; cached per entry.
     |
     |  is_junction(self, /)
     |      Return True if the entry is a junction; cached per entry.
     |
     |  is_symlink(self, /)
     |      Return True if the entry is a symbolic link; cached per entry.
     |
     |  stat(self, /, *, follow_symlinks=True)
     |      Return stat_result object for the entry; cached per entry.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__(...)
     |      See PEP 585
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  name
     |      the entry's base filename, relative to scandir() "path" argument
     |
     |  path
     |      the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)

    error = class OSError(Exception)
     |  Base class for I/O related errors.
     |
     |  Method resolution order:
     |      OSError
     |      Exception
     |      BaseException
     |      object
     |
     |  Built-in subclasses:
     |      BlockingIOError
     |      ChildProcessError
     |      ConnectionError
     |      FileExistsError
     |      ... and 7 other subclasses
     |
     |  Methods defined here:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  characters_written
     |
     |  errno
     |      POSIX exception code
     |
     |  filename
     |      exception filename
     |
     |  filename2
     |      second exception filename
     |
     |  strerror
     |      exception strerror
     |
     |  winerror
     |      Win32 exception code
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class stat_result(builtins.tuple)
     |  stat_result(iterable=(), /)
     |
     |  stat_result: Result from stat, fstat, or lstat.
     |
     |  This object may be accessed either as a tuple of
     |    (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
     |  or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.
     |
     |  Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,
     |  or st_flags, they are available as attributes only.
     |
     |  See os.stat for more information.
     |
     |  Method resolution order:
     |      stat_result
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  st_atime
     |      time of last access
     |
     |  st_atime_ns
     |      time of last access in nanoseconds
     |
     |  st_birthtime
     |      time of creation
     |
     |  st_birthtime_ns
     |      time of creation in nanoseconds
     |
     |  st_ctime
     |      time of last change
     |
     |  st_ctime_ns
     |      time of last change in nanoseconds
     |
     |  st_dev
     |      device
     |
     |  st_file_attributes
     |      Windows file attribute bits
     |
     |  st_gid
     |      group ID of owner
     |
     |  st_ino
     |      inode
     |
     |  st_mode
     |      protection bits
     |
     |  st_mtime
     |      time of last modification
     |
     |  st_mtime_ns
     |      time of last modification in nanoseconds
     |
     |  st_nlink
     |      number of hard links
     |
     |  st_reparse_tag
     |      Windows reparse tag
     |
     |  st_size
     |      total size, in bytes
     |
     |  st_uid
     |      user ID of owner
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('st_mode', 'st_ino', 'st_dev', 'st_nlink', 'st_uid',...
     |
     |  n_fields = 20
     |
     |  n_sequence_fields = 10
     |
     |  n_unnamed_fields = 3
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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__(self, /)
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class statvfs_result(builtins.tuple)
     |  statvfs_result(iterable=(), /)
     |
     |  statvfs_result: Result from statvfs or fstatvfs.
     |
     |  This object may be accessed either as a tuple of
     |    (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),
     |  or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.
     |
     |  See os.statvfs for more information.
     |
     |  Method resolution order:
     |      statvfs_result
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  f_bavail
     |
     |  f_bfree
     |
     |  f_blocks
     |
     |  f_bsize
     |
     |  f_favail
     |
     |  f_ffree
     |
     |  f_files
     |
     |  f_flag
     |
     |  f_frsize
     |
     |  f_fsid
     |
     |  f_namemax
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bav...
     |
     |  n_fields = 11
     |
     |  n_sequence_fields = 10
     |
     |  n_unnamed_fields = 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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__(self, /)
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class terminal_size(builtins.tuple)
     |  terminal_size(iterable=(), /)
     |
     |  A tuple of (columns, lines) for holding terminal window size
     |
     |  Method resolution order:
     |      terminal_size
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  columns
     |      width of the terminal window in characters
     |
     |  lines
     |      height of the terminal window in characters
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('columns', 'lines')
     |
     |  n_fields = 2
     |
     |  n_sequence_fields = 2
     |
     |  n_unnamed_fields = 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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__(self, /)
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class times_result(builtins.tuple)
     |  times_result(iterable=(), /)
     |
     |  times_result: Result from os.times().
     |
     |  This object may be accessed either as a tuple of
     |    (user, system, children_user, children_system, elapsed),
     |  or via the attributes user, system, children_user, children_system,
     |  and elapsed.
     |
     |  See os.times for more information.
     |
     |  Method resolution order:
     |      times_result
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  children_system
     |      system time of children
     |
     |  children_user
     |      user time of children
     |
     |  elapsed
     |      elapsed time since an arbitrary point in the past
     |
     |  system
     |      system time
     |
     |  user
     |      user time
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('user', 'system', 'children_user', 'children_system'...
     |
     |  n_fields = 5
     |
     |  n_sequence_fields = 5
     |
     |  n_unnamed_fields = 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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__(self, /)
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

    class uname_result(builtins.tuple)
     |  uname_result(iterable=(), /)
     |
     |  uname_result: Result from os.uname().
     |
     |  This object may be accessed either as a tuple of
     |    (sysname, nodename, release, version, machine),
     |  or via the attributes sysname, nodename, release, version, and machine.
     |
     |  See os.uname for more information.
     |
     |  Method resolution order:
     |      uname_result
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  machine
     |      hardware identifier
     |
     |  nodename
     |      name of machine on network (implementation-defined)
     |
     |  release
     |      operating system release
     |
     |  sysname
     |      operating system name
     |
     |  version
     |      operating system version
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __match_args__ = ('sysname', 'nodename', 'release', 'version', 'machin...
     |
     |  n_fields = 5
     |
     |  n_sequence_fields = 5
     |
     |  n_unnamed_fields = 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(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__(self, /)
     |
     |  __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.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

FUNCTIONS
    _exit(status)
        Exit to the system with specified status, without normal exit processing.

    abort()
        Abort the interpreter immediately.

        This function 'dumps core' or otherwise fails in the hardest way possible
        on the hosting operating system.  This function never returns.

    access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)
        Use the real uid/gid to test for access to a path.

          path
            Path to be tested; can be string, bytes, or a path-like object.
          mode
            Operating-system mode bitfield.  Can be F_OK to test existence,
            or the inclusive-OR of R_OK, W_OK, and X_OK.
          dir_fd
            If not None, it should be a file descriptor open to a directory,
            and path should be relative; path will then be relative to that
            directory.
          effective_ids
            If True, access will use the effective uid/gid instead of
            the real uid/gid.
          follow_symlinks
            If False, and the last element of the path is a symbolic link,
            access will examine the symbolic link itself instead of the file
            the link points to.

        dir_fd, effective_ids, and follow_symlinks may not be implemented
          on your platform.  If they are unavailable, using them will raise a
          NotImplementedError.

        Note that most operations will use the effective uid/gid, therefore this
          routine can be used in a suid/sgid environment to test if the invoking user
          has the specified access to the path.

    chdir(path)
        Change the current working directory to the specified path.

        path may always be specified as a string.
        On some platforms, path may also be specified as an open file descriptor.
          If this functionality is unavailable, using it raises an exception.

    chmod(path, mode, *, dir_fd=None, follow_symlinks=True)
        Change the access permissions of a file.

          path
            Path to be modified.  May always be specified as a str, bytes, or a path-like object.
            On some platforms, path may also be specified as an open file descriptor.
            If this functionality is unavailable, using it raises an exception.
          mode
            Operating-system mode bitfield.
            Be careful when using number literals for *mode*. The conventional UNIX notation for
            numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in
            Python.
          dir_fd
            If not None, it should be a file descriptor open to a directory,
            and path should be relative; path will then be relative to that
            directory.
          follow_symlinks
            If False, and the last element of the path is a symbolic link,
            chmod will modify the symbolic link itself instead of the file
            the link points to.

        It is an error to use dir_fd or follow_symlinks when specifying path as
          an open file descriptor.
        dir_fd and follow_symlinks may not be implemented on your platform.
          If they are unavailable, using them will raise a NotImplementedError.

    close(fd)
        Close a file descriptor.

    closerange(fd_low, fd_high, /)
        Closes all file descriptors in [fd_low, fd_high), ignoring errors.

    cpu_count()
        Return the number of CPUs in the system; return None if indeterminable.

        This number is not equivalent to the number of CPUs the current process can
        use.  The number of usable CPUs can be obtained with
        ``len(os.sched_getaffinity(0))``

    device_encoding(fd)
        Return a string describing the encoding of a terminal's file descriptor.

        The file descriptor must be attached to a terminal.
        If the device is not a terminal, return None.

    dup(fd, /)
        Return a duplicate of a file descriptor.

    dup2(fd, fd2, inheritable=True)
        Duplicate file descriptor.

    execl(file, *args)
        execl(file, *args)

        Execute the executable file with argument list args, replacing the
        current process.

    execle(file, *args)
        execle(file, *args, env)

        Execute the executable file with argument list args and
        environment env, replacing the current process.

    execlp(file, *args)
        execlp(file, *args)

        Execute the executable file (which is searched for along $PATH)
        with argument list args, replacing the current process.

    execlpe(file, *args)
        execlpe(file, *args, env)

        Execute the executable file (which is searched for along $PATH)
        with argument list args and environment env, replacing the current
        process.

    execv(path, argv, /)
        Execute an executable path with arguments, replacing current process.

        path
          Path of executable file.
        argv
          Tuple or list of strings.

    execve(path, argv, env)
        Execute an executable path with arguments, replacing current process.

        path
          Path of executable file.
        argv
          Tuple or list of strings.
        env
          Dictionary of strings mapping to strings.

    execvp(file, args)
        execvp(file, args)

        Execute the executable file (which is searched for along $PATH)
        with argument list args, replacing the current process.
        args may be a list or tuple of strings.

    execvpe(file, args, env)
        execvpe(file, args, env)

        Execute the executable file (which is searched for along $PATH)
        with argument list args and environment env, replacing the
        current process.
        args may be a list or tuple of strings.

    fdopen(fd, mode='r', buffering=-1, encoding=None, *args, **kwargs)

    fsdecode(filename)
        Decode filename (an os.PathLike, bytes, or str) from the filesystem
        encoding with 'surrogateescape' error handler, return str unchanged. On
        Windows, use 'strict' error handler if the file system encoding is
        'mbcs' (which is the default encoding).

    fsencode(filename)
        Encode filename (an os.PathLike, bytes, or str) to the filesystem
        encoding with 'surrogateescape' error handler, return bytes unchanged.
        On Windows, use 'strict' error handler if the file system encoding is
        'mbcs' (which is the default encoding).

    fspath(path)
        Return the file system path representation of the object.

        If the object is str or bytes, then allow it to pass through as-is. If the
        object defines __fspath__(), then return the result of that method. All other
        types raise a TypeError.

    fstat(fd)
        Perform a stat system call on the given file descriptor.

        Like stat(), but for an open file descriptor.
        Equivalent to os.stat(fd).

    fsync(fd)
        Force write of fd to disk.

    ftruncate(fd, length, /)
        Truncate a file, specified by file descriptor, to a specific length.

    get_blocking(fd, /)
        Get the blocking mode of the file descriptor.

        Return False if the O_NONBLOCK flag is set, True if the flag is cleared.

    get_exec_path(env=None)
        Returns the sequence of directories that will be searched for the
        named executable (similar to a shell) when launching a process.

        *env* must be an environment variable dict or None.  If *env* is None,
        os.environ will be used.

    get_handle_inheritable(handle, /)
        Get the close-on-exe flag of the specified file descriptor.

    get_inheritable(fd, /)
        Get the close-on-exe flag of the specified file descriptor.

    get_terminal_size(...)
        Return the size of the terminal window as (columns, lines).

        The optional argument fd (default standard output) specifies
        which file descriptor should be queried.

        If the file descriptor is not connected to a terminal, an OSError
        is thrown.

        This function will only be defined if an implementation is
        available for this system.

        shutil.get_terminal_size is the high-level function which should
        normally be used, os.get_terminal_size is the low-level implementation.

    getcwd()
        Return a unicode string representing the current working directory.

    getcwdb()
        Return a bytes string representing the current working directory.

    getenv(key, default=None)
        Get an environment variable, return None if it doesn't exist.
        The optional second argument can specify an alternate default.
        key, default and the result are str.

    getlogin()
        Return the actual login name.

    getpid()
        Return the current process id.

    getppid()
        Return the parent's process id.

        If the parent process has already exited, Windows machines will still
        return its id; others systems will return the id of the 'init' process (1).

    isatty(fd, /)
        Return True if the fd is connected to a terminal.

        Return True if the file descriptor is an open file descriptor
        connected to the slave end of a terminal.

    kill(pid, signal, /)
        Kill a process with a signal.

    link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)
        Create a hard link to a file.

        If either src_dir_fd or dst_dir_fd is not None, it should be a file
          descriptor open to a directory, and the respective path string (src or dst)
          should be relative; the path will then be relative to that directory.
        If follow_symlinks is False, and the last element of src is a symbolic
          link, link will create a link to the symbolic link itself instead of the
          file the link points to.
        src_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your
          platform.  If they are unavailable, using them will raise a
          NotImplementedError.

    listdir(path=None)
        Return a list containing the names of the files in the directory.

        path can be specified as either str, bytes, or a path-like object.  If path is bytes,
          the filenames returned will also be bytes; in all other circumstances
          the filenames returned will be str.
        If path is None, uses the path='.'.
        On some platforms, path may also be specified as an open file descriptor;\
          the file descriptor must refer to a directory.
          If this functionality is unavailable, using it raises NotImplementedError.

        The list is in arbitrary order.  It does not include the special
        entries '.' and '..' even if they are present in the directory.

    listdrives()
        Return a list containing the names of drives in the system.

        A drive name typically looks like 'C:\\'.

    listmounts(volume)
        Return a list containing mount points for a particular volume.

        'volume' should be a GUID path as returned from os.listvolumes.

    listvolumes()
        Return a list containing the volumes in the system.

        Volumes are typically represented as a GUID path.

    lseek(fd, position, whence, /)
        Set the position of a file descriptor.  Return the new position.

          fd
            An open file descriptor, as returned by os.open().
          position
            Position, interpreted relative to 'whence'.
          whence
            The relative position to seek from. Valid values are:
            - SEEK_SET: seek from the start of the file.
            - SEEK_CUR: seek from the current file position.
            - SEEK_END: seek from the end of the file.

        The return value is the number of bytes relative to the beginning of the file.

    lstat(path, *, dir_fd=None)
        Perform a stat system call on the given path, without following symbolic links.

        Like stat(), but do not follow symbolic links.
        Equivalent to stat(path, follow_symlinks=False).

    makedirs(name, mode=511, exist_ok=False)
        makedirs(name [, mode=0o777][, exist_ok=False])

        Super-mkdir; create a leaf directory and all intermediate ones.  Works like
        mkdir, except that any intermediate path segment (not just the rightmost)
        will be created if it does not exist. If the target directory already
        exists, raise an OSError if exist_ok is False. Otherwise no exception is
        raised.  This is recursive.

    mkdir(path, mode=511, *, dir_fd=None)
        Create a directory.

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        dir_fd may not be implemented on your platform.
          If it is unavailable, using it will raise a NotImplementedError.

        The mode argument is ignored on Windows. Where it is used, the current umask
        value is first masked out.

    open(path, flags, mode=511, *, dir_fd=None)
        Open a file for low level IO.  Returns a file descriptor (integer).

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        dir_fd may not be implemented on your platform.
          If it is unavailable, using it will raise a NotImplementedError.

    pipe()
        Create a pipe.

        Returns a tuple of two file descriptors:
          (read_fd, write_fd)

    popen(cmd, mode='r', buffering=-1)

    putenv(name, value, /)
        Change or add an environment variable.

    read(fd, length, /)
        Read from a file descriptor.  Returns a bytes object.

    readlink(path, *, dir_fd=None)
        Return a string representing the path to which the symbolic link points.

        If dir_fd is not None, it should be a file descriptor open to a directory,
        and path should be relative; path will then be relative to that directory.

        dir_fd may not be implemented on your platform.  If it is unavailable,
        using it will raise a NotImplementedError.

    remove(path, *, dir_fd=None)
        Remove a file (same as unlink()).

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        dir_fd may not be implemented on your platform.
          If it is unavailable, using it will raise a NotImplementedError.

    removedirs(name)
        removedirs(name)

        Super-rmdir; remove a leaf directory and all empty intermediate
        ones.  Works like rmdir except that, if the leaf directory is
        successfully removed, directories corresponding to rightmost path
        segments will be pruned away until either the whole path is
        consumed or an error occurs.  Errors during this latter phase are
        ignored -- they generally mean that a directory was not empty.

    rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
        Rename a file or directory.

        If either src_dir_fd or dst_dir_fd is not None, it should be a file
          descriptor open to a directory, and the respective path string (src or dst)
          should be relative; the path will then be relative to that directory.
        src_dir_fd and dst_dir_fd, may not be implemented on your platform.
          If they are unavailable, using them will raise a NotImplementedError.

    renames(old, new)
        renames(old, new)

        Super-rename; create directories as necessary and delete any left
        empty.  Works like rename, except creation of any intermediate
        directories needed to make the new pathname good is attempted
        first.  After the rename, directories corresponding to rightmost
        path segments of the old name will be pruned until either the
        whole path is consumed or a nonempty directory is found.

        Note: this function can fail with the new directory structure made
        if you lack permissions needed to unlink the leaf directory or
        file.

    replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
        Rename a file or directory, overwriting the destination.

        If either src_dir_fd or dst_dir_fd is not None, it should be a file
          descriptor open to a directory, and the respective path string (src or dst)
          should be relative; the path will then be relative to that directory.
        src_dir_fd and dst_dir_fd, may not be implemented on your platform.
          If they are unavailable, using them will raise a NotImplementedError.

    rmdir(path, *, dir_fd=None)
        Remove a directory.

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        dir_fd may not be implemented on your platform.
          If it is unavailable, using it will raise a NotImplementedError.

    scandir(path=None)
        Return an iterator of DirEntry objects for given path.

        path can be specified as either str, bytes, or a path-like object.  If path
        is bytes, the names of yielded DirEntry objects will also be bytes; in
        all other circumstances they will be str.

        If path is None, uses the path='.'.

    set_blocking(fd, blocking, /)
        Set the blocking mode of the specified file descriptor.

        Set the O_NONBLOCK flag if blocking is False,
        clear the O_NONBLOCK flag otherwise.

    set_handle_inheritable(handle, inheritable, /)
        Set the inheritable flag of the specified handle.

    set_inheritable(fd, inheritable, /)
        Set the inheritable flag of the specified file descriptor.

    spawnl(mode, file, *args)
        spawnl(mode, file, *args) -> integer

        Execute file with arguments from args in a subprocess.
        If mode == P_NOWAIT return the pid of the process.
        If mode == P_WAIT return the process's exit code if it exits normally;
        otherwise return -SIG, where SIG is the signal that killed it.

    spawnle(mode, file, *args)
        spawnle(mode, file, *args, env) -> integer

        Execute file with arguments from args in a subprocess with the
        supplied environment.
        If mode == P_NOWAIT return the pid of the process.
        If mode == P_WAIT return the process's exit code if it exits normally;
        otherwise return -SIG, where SIG is the signal that killed it.

    spawnv(mode, path, argv, /)
        Execute the program specified by path in a new process.

        mode
          Mode of process creation.
        path
          Path of executable file.
        argv
          Tuple or list of strings.

    spawnve(mode, path, argv, env, /)
        Execute the program specified by path in a new process.

        mode
          Mode of process creation.
        path
          Path of executable file.
        argv
          Tuple or list of strings.
        env
          Dictionary of strings mapping to strings.

    startfile(...)
        Start a file with its associated application.

        When "operation" is not specified or "open", this acts like
        double-clicking the file in Explorer, or giving the file name as an
        argument to the DOS "start" command: the file is opened with whatever
        application (if any) its extension is associated.
        When another "operation" is given, it specifies what should be done with
        the file.  A typical operation is "print".

        "arguments" is passed to the application, but should be omitted if the
        file is a document.

        "cwd" is the working directory for the operation. If "filepath" is
        relative, it will be resolved against this directory. This argument
        should usually be an absolute path.

        "show_cmd" can be used to override the recommended visibility option.
        See the Windows ShellExecute documentation for values.

        startfile returns as soon as the associated application is launched.
        There is no option to wait for the application to close, and no way
        to retrieve the application's exit status.

        The filepath is relative to the current directory.  If you want to use
        an absolute path, make sure the first character is not a slash ("/");
        the underlying Win32 ShellExecute function doesn't work if it is.

    stat(path, *, dir_fd=None, follow_symlinks=True)
        Perform a stat system call on the given path.

          path
            Path to be examined; can be string, bytes, a path-like object or
            open-file-descriptor int.
          dir_fd
            If not None, it should be a file descriptor open to a directory,
            and path should be a relative string; path will then be relative to
            that directory.
          follow_symlinks
            If False, and the last element of the path is a symbolic link,
            stat will examine the symbolic link itself instead of the file
            the link points to.

        dir_fd and follow_symlinks may not be implemented
          on your platform.  If they are unavailable, using them will raise a
          NotImplementedError.

        It's an error to use dir_fd or follow_symlinks when specifying path as
          an open file descriptor.

    strerror(code, /)
        Translate an error code to a message string.

    symlink(src, dst, target_is_directory=False, *, dir_fd=None)
        Create a symbolic link pointing to src named dst.

        target_is_directory is required on Windows if the target is to be
          interpreted as a directory.  (On Windows, symlink requires
          Windows 6.0 or greater, and raises a NotImplementedError otherwise.)
          target_is_directory is ignored on non-Windows platforms.

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        dir_fd may not be implemented on your platform.
          If it is unavailable, using it will raise a NotImplementedError.

    system(command)
        Execute the command in a subshell.

    times()
        Return a collection containing process timing information.

        The object returned behaves like a named tuple with these fields:
          (utime, stime, cutime, cstime, elapsed_time)
        All fields are floating-point numbers.

    truncate(path, length)
        Truncate a file, specified by path, to a specific length.

        On some platforms, path may also be specified as an open file descriptor.
          If this functionality is unavailable, using it raises an exception.

    umask(mask, /)
        Set the current numeric umask and return the previous umask.

    unlink(path, *, dir_fd=None)
        Remove a file (same as remove()).

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        dir_fd may not be implemented on your platform.
          If it is unavailable, using it will raise a NotImplementedError.

    unsetenv(name, /)
        Delete an environment variable.

    urandom(size, /)
        Return a bytes object containing random bytes suitable for cryptographic use.

    utime(...)
        Set the access and modified time of path.

        path may always be specified as a string.
        On some platforms, path may also be specified as an open file descriptor.
          If this functionality is unavailable, using it raises an exception.

        If times is not None, it must be a tuple (atime, mtime);
            atime and mtime should be expressed as float seconds since the epoch.
        If ns is specified, it must be a tuple (atime_ns, mtime_ns);
            atime_ns and mtime_ns should be expressed as integer nanoseconds
            since the epoch.
        If times is None and ns is unspecified, utime uses the current time.
        Specifying tuples for both times and ns is an error.

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and path should be relative; path will then be relative to that directory.
        If follow_symlinks is False, and the last element of the path is a symbolic
          link, utime will modify the symbolic link itself instead of the file the
          link points to.
        It is an error to use dir_fd or follow_symlinks when specifying path
          as an open file descriptor.
        dir_fd and follow_symlinks may not be available on your platform.
          If they are unavailable, using them will raise a NotImplementedError.

    waitpid(pid, options, /)
        Wait for completion of a given process.

        Returns a tuple of information regarding the process:
            (pid, status << 8)

        The options argument is ignored on Windows.

    waitstatus_to_exitcode(status)
        Convert a wait status to an exit code.

        On Unix:

        * If WIFEXITED(status) is true, return WEXITSTATUS(status).
        * If WIFSIGNALED(status) is true, return -WTERMSIG(status).
        * Otherwise, raise a ValueError.

        On Windows, return status shifted right by 8 bits.

        On Unix, if the process is being traced or if waitpid() was called with
        WUNTRACED option, the caller must first check if WIFSTOPPED(status) is true.
        This function must not be called if WIFSTOPPED(status) is true.

    walk(top, topdown=True, onerror=None, followlinks=False)
        Directory tree generator.

        For each directory in the directory tree rooted at top (including top
        itself, but excluding '.' and '..'), yields a 3-tuple

            dirpath, dirnames, filenames

        dirpath is a string, the path to the directory.  dirnames is a list of
        the names of the subdirectories in dirpath (including symlinks to directories,
        and excluding '.' and '..').
        filenames is a list of the names of the non-directory files in dirpath.
        Note that the names in the lists are just names, with no path components.
        To get a full path (which begins with top) to a file or directory in
        dirpath, do os.path.join(dirpath, name).

        If optional arg 'topdown' is true or not specified, the triple for a
        directory is generated before the triples for any of its subdirectories
        (directories are generated top down).  If topdown is false, the triple
        for a directory is generated after the triples for all of its
        subdirectories (directories are generated bottom up).

        When topdown is true, the caller can modify the dirnames list in-place
        (e.g., via del or slice assignment), and walk will only recurse into the
        subdirectories whose names remain in dirnames; this can be used to prune the
        search, or to impose a specific order of visiting.  Modifying dirnames when
        topdown is false has no effect on the behavior of os.walk(), since the
        directories in dirnames have already been generated by the time dirnames
        itself is generated. No matter the value of topdown, the list of
        subdirectories is retrieved before the tuples for the directory and its
        subdirectories are generated.

        By default errors from the os.scandir() call are ignored.  If
        optional arg 'onerror' is specified, it should be a function; it
        will be called with one argument, an OSError instance.  It can
        report the error to continue with the walk, or raise the exception
        to abort the walk.  Note that the filename is available as the
        filename attribute of the exception object.

        By default, os.walk does not follow symbolic links to subdirectories on
        systems that support them.  In order to get this functionality, set the
        optional argument 'followlinks' to true.

        Caution:  if you pass a relative pathname for top, don't change the
        current working directory between resumptions of walk.  walk never
        changes the current directory, and assumes that the client doesn't
        either.

        Example:

        import os
        from os.path import join, getsize
        for root, dirs, files in os.walk('python/Lib/email'):
            print(root, "consumes ")
            print(sum(getsize(join(root, name)) for name in files), end=" ")
            print("bytes in", len(files), "non-directory files")
            if 'CVS' in dirs:
                dirs.remove('CVS')  # don't visit CVS directories

    write(fd, data, /)
        Write a bytes object to a file descriptor.

DATA
    EX_OK = 0
    F_OK = 0
    O_APPEND = 8
    O_BINARY = 32768
    O_CREAT = 256
    O_EXCL = 1024
    O_NOINHERIT = 128
    O_RANDOM = 16
    O_RDONLY = 0
    O_RDWR = 2
    O_SEQUENTIAL = 32
    O_SHORT_LIVED = 4096
    O_TEMPORARY = 64
    O_TEXT = 16384
    O_TRUNC = 512
    O_WRONLY = 1
    P_DETACH = 4
    P_NOWAIT = 1
    P_NOWAITO = 3
    P_OVERLAY = 2
    P_WAIT = 0
    R_OK = 4
    SEEK_CUR = 1
    SEEK_END = 2
    SEEK_SET = 0
    TMP_MAX = 2147483647
    W_OK = 2
    X_OK = 1
    __all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...
    altsep = '/'
    curdir = '.'
    defpath = r'.;C:\bin'
    devnull = 'nul'
    environ = environ({'ALLUSERSPROFILE': 'C:\\ProgramData', '...undled\\l...
    extsep = '.'
    linesep = '\r\n'
    name = 'nt'
    pardir = '..'
    pathsep = ';'
    sep = r'\'
    supports_bytes_environ = False

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\os.py

Python Library Documentation: function pack_bitstrings in module faiss.extra_wrappers

pack_bitstrings(a, nbit)
    Pack a set integers (i, j) where i=0:n and j=0:M into
    n bitstrings.
    Output is an uint8 array of size (n, code_size), where code_size is
    such that at most 7 bits per code are wasted.

    If nbit is an integer: all entries takes nbit bits.
    If nbit is an array: entry (i, j) takes nbit[j] bits.

Python Library Documentation: function pairwise_L2sqr in module faiss.swigfaiss

pairwise_L2sqr(d, nq, xq, nb, xb, dis, ldq=-1, ldb=-1, ldd=-1)
     Compute pairwise distances between sets of vectors

    :type d: int
    :param d:     dimension of the vectors
    :type nq: int
    :param nq:    nb of query vectors
    :type nb: int
    :param nb:    nb of database vectors
    :type xq: float
    :param xq:    query vectors (size nq * d)
    :type xb: float
    :param xb:    database vectors (size nb * d)
    :type dis: float
    :param dis:   output distances (size nq * nb)
    :param ldq,ldb:, ldd strides for the matrices

Python Library Documentation: function pairwise_distance_gpu in module faiss.gpu_wrappers

pairwise_distance_gpu(res, xq, xb, D=None, metric=1, device=-1)
    Compute all pairwise distances between xq and xb on one GPU without constructing an index

    Parameters
    ----------
    res : StandardGpuResources
        GPU resources to use during computation
    xq : array_like
        Query vectors, shape (nq, d) where d is appropriate for the index.
        `dtype` must be float32.
    xb : array_like
        Database vectors, shape (nb, d) where d is appropriate for the index.
        `dtype` must be float32.
    D : array_like, optional
        Output array for all pairwise distances, shape (nq, nb)
    metric : MetricType, optional
        Distance measure to use (either METRIC_L2 or METRIC_INNER_PRODUCT)
    device: int, optional
        Which CUDA device in the system to run the search on. -1 indicates that
        the current thread-local device state (via cudaGetDevice) should be used
        (can also be set via torch.cuda.set_device in PyTorch)
        Otherwise, an integer 0 <= device < numDevices indicates the GPU on which
        the computation should be run

    Returns
    -------
    D : array_like
        All pairwise distances, shape (nq, nb)

Python Library Documentation: function pairwise_distances in module faiss.extra_wrappers

pairwise_distances(xq, xb, metric=1, metric_arg=0)
    compute the whole pairwise distance matrix between two sets of
    vectors

Python Library Documentation: function pairwise_extra_distances in module faiss.swigfaiss

pairwise_extra_distances(d, nq, xq, nb, xb, mt, metric_arg, dis, ldq=-1, ldb=-1, ldd=-1)

Python Library Documentation: function pairwise_indexed_L2sqr in module faiss.swigfaiss

pairwise_indexed_L2sqr(d, n, x, ix, y, iy, dis)
     compute dis[j] = L2sqr(x[ix[j]], y[iy[j]]) forall j=0..n-1

    :type x: float
    :param x:  size (max(ix) + 1, d)
    :type y: float
    :param y:  size (max(iy) + 1, d)
    :type ix: int
    :param ix: size n
    :type iy: int
    :param iy: size n
    :type dis: float
    :param dis: size n

Python Library Documentation: function pairwise_indexed_inner_product in module faiss.swigfaiss

pairwise_indexed_inner_product(d, n, x, ix, y, iy, dis)
     compute dis[j] = inner_product(x[ix[j]], y[iy[j]]) forall j=0..n-1

    :type x: float
    :param x:  size (max(ix) + 1, d)
    :type y: float
    :param y:  size (max(iy) + 1, d)
    :type ix: int
    :param ix: size n
    :type iy: int
    :param iy: size n
    :type dis: float
    :param dis: size n

Python Library Documentation: module platform

NAME
    platform

MODULE REFERENCE
    https://docs.python.org/3.12/library/platform.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module tries to retrieve as much platform-identifying data as
    possible. It makes this information available via function APIs.

    If called from the command line, it prints the platform
    information concatenated as single string to stdout. The output
    format is usable as part of a filename.

CLASSES
    uname_result_base(builtins.tuple)
        uname_result

    class uname_result(uname_result_base)
     |  uname_result(system, node, release, version, machine)
     |
     |  A uname_result that's largely compatible with a
     |  simple namedtuple except that 'processor' is
     |  resolved late and cached to avoid calling "uname"
     |  except when needed.
     |
     |  Method resolution order:
     |      uname_result
     |      uname_result_base
     |      builtins.tuple
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  processor = <functools.cached_property object>
     |  __getitem__(self, key)
     |      Return self[key].
     |
     |  __iter__(self)
     |      Implement iter(self).
     |
     |  __len__(self)
     |      Return len(self).
     |
     |  __reduce__(self)
     |      Helper for pickle.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  _make(iterable)
     |      Make a new uname_result_base object from a sequence or iterable
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  _fields = ('system', 'node', 'release', 'version', 'machine', 'process...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from uname_result_base:
     |
     |  __getnewargs__(self) from collections.uname_result_base
     |      Return self as a plain tuple.  Used by copy and pickle.
     |
     |  __repr__(self) from collections.uname_result_base
     |      Return a nicely formatted representation string
     |
     |  _asdict(self) from collections.uname_result_base
     |      Return a new dict which maps field names to their values.
     |
     |  _replace(self, /, **kwds) from collections.uname_result_base
     |      Return a new uname_result_base object replacing specified fields with new values
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from uname_result_base:
     |
     |  __new__(_cls, system, node, release, version, machine) from namedtuple_uname_result_base.uname_result_base
     |      Create new instance of uname_result_base(system, node, release, version, machine)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from uname_result_base:
     |
     |  system
     |      Alias for field number 0
     |
     |  node
     |      Alias for field number 1
     |
     |  release
     |      Alias for field number 2
     |
     |  version
     |      Alias for field number 3
     |
     |  machine
     |      Alias for field number 4
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from uname_result_base:
     |
     |  __match_args__ = ('system', 'node', 'release', 'version', 'machine')
     |
     |  _field_defaults = {}
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return bool(key in self).
     |
     |  __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.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.tuple:
     |
     |  __class_getitem__(...)
     |      See PEP 585

FUNCTIONS
    architecture(executable='C:\\Users\\Youse\\AppData\\Local\\Programs\\Python\\Python312\\python.exe', bits='', linkage='')
        Queries the given executable (defaults to the Python interpreter
        binary) for various architecture information.

        Returns a tuple (bits, linkage) which contains information about
        the bit architecture and the linkage format used for the
        executable. Both values are returned as strings.

        Values that cannot be determined are returned as given by the
        parameter presets. If bits is given as '', the sizeof(pointer)
        (or sizeof(long) on Python version < 1.5.2) is used as
        indicator for the supported pointer size.

        The function relies on the system's "file" command to do the
        actual work. This is available on most if not all Unix
        platforms. On some non-Unix platforms where the "file" command
        does not exist and the executable is set to the Python interpreter
        binary defaults from _default_architecture are used.

    freedesktop_os_release()
        Return operation system identification from freedesktop.org os-release

    java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', ''))
        Version interface for Jython.

        Returns a tuple (release, vendor, vminfo, osinfo) with vminfo being
        a tuple (vm_name, vm_release, vm_vendor) and osinfo being a
        tuple (os_name, os_version, os_arch).

        Values which cannot be determined are set to the defaults
        given as parameters (which all default to '').

    libc_ver(executable=None, lib='', version='', chunksize=16384)
        Tries to determine the libc version that the file executable
        (which defaults to the Python interpreter) is linked against.

        Returns a tuple of strings (lib,version) which default to the
        given parameters in case the lookup fails.

        Note that the function has intimate knowledge of how different
        libc versions add symbols to the executable and thus is probably
        only usable for executables compiled using gcc.

        The file is read and scanned in chunks of chunksize bytes.

    mac_ver(release='', versioninfo=('', '', ''), machine='')
        Get macOS version information and return it as tuple (release,
        versioninfo, machine) with versioninfo being a tuple (version,
        dev_stage, non_release_version).

        Entries which cannot be determined are set to the parameter values
        which default to ''. All tuple entries are strings.

    machine()
        Returns the machine type, e.g. 'i386'

        An empty string is returned if the value cannot be determined.

    node()
        Returns the computer's network name (which may not be fully
        qualified)

        An empty string is returned if the value cannot be determined.

    platform(aliased=False, terse=False)
        Returns a single string identifying the underlying platform
        with as much useful information as possible (but no more :).

        The output is intended to be human readable rather than
        machine parseable. It may look different on different
        platforms and this is intended.

        If "aliased" is true, the function will use aliases for
        various platforms that report system names which differ from
        their common names, e.g. SunOS will be reported as
        Solaris. The system_alias() function is used to implement
        this.

        Setting terse to true causes the function to return only the
        absolute minimum information needed to identify the platform.

    processor()
        Returns the (true) processor name, e.g. 'amdk6'

        An empty string is returned if the value cannot be
        determined. Note that many platforms do not provide this
        information or simply return the same value as for machine(),
        e.g.  NetBSD does this.

    python_branch()
        Returns a string identifying the Python implementation
        branch.

        For CPython this is the SCM branch from which the
        Python binary was built.

        If not available, an empty string is returned.

    python_build()
        Returns a tuple (buildno, builddate) stating the Python
        build number and date as strings.

    python_compiler()
        Returns a string identifying the compiler used for compiling
        Python.

    python_implementation()
        Returns a string identifying the Python implementation.

        Currently, the following implementations are identified:
          'CPython' (C implementation of Python),
          'Jython' (Java implementation of Python),
          'PyPy' (Python implementation of Python).

    python_revision()
        Returns a string identifying the Python implementation
        revision.

        For CPython this is the SCM revision from which the
        Python binary was built.

        If not available, an empty string is returned.

    python_version()
        Returns the Python version as string 'major.minor.patchlevel'

        Note that unlike the Python sys.version, the returned value
        will always include the patchlevel (it defaults to 0).

    python_version_tuple()
        Returns the Python version as tuple (major, minor, patchlevel)
        of strings.

        Note that unlike the Python sys.version, the returned value
        will always include the patchlevel (it defaults to 0).

    release()
        Returns the system's release, e.g. '2.2.0' or 'NT'

        An empty string is returned if the value cannot be determined.

    system()
        Returns the system/OS name, e.g. 'Linux', 'Windows' or 'Java'.

        An empty string is returned if the value cannot be determined.

    system_alias(system, release, version)
        Returns (system, release, version) aliased to common
        marketing names used for some systems.

        It also does some reordering of the information in some cases
        where it would otherwise cause confusion.

    uname()
        Fairly portable uname interface. Returns a tuple
        of strings (system, node, release, version, machine, processor)
        identifying the underlying platform.

        Note that unlike the os.uname function this also returns
        possible processor information as an additional tuple entry.

        Entries which cannot be determined are set to ''.

    version()
        Returns the system's release version, e.g. '#3 on degas'

        An empty string is returned if the value cannot be determined.

    win32_edition()

    win32_is_iot()

    win32_ver(release='', version='', csd='', ptype='')

DATA
    __copyright__ = '\n    Copyright (c) 1999-2000, Marc-Andre Lemburg... ...

VERSION
    1.0.8

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\platform.py

Python Library Documentation: function popcount32 in module faiss.swigfaiss

popcount32(x)

Python Library Documentation: function popcount64 in module faiss.swigfaiss

popcount64(x)

Python Library Documentation: function populate_block_aux_from_flat_storage in module faiss.swigfaiss

populate_block_aux_from_flat_storage(flat_storage, codes, num_vectors, bbs, M2, old_block_stride, new_block_stride, storage_size, id_map=None)
     [LEGACY FORMAT SUPPORT] Migrate block data from old I/O format to new
    format.

    This function is used only when reading indexes saved with the legacy format
    (fourcc "Irfs"/"Iwrf") to convert them to the new embedded auxiliary data
    format. Not needed for indexes saved with the new format ("Irfn"/"Iwrn").

    Re-layouts blocks in-place and copies aux data from flat_storage.

    :type flat_storage: std::vector< uint8_t >
    :param flat_storage:       legacy per-vector aux data indexed by global ID
    :type codes: faiss::AlignedTable< uint8_t >
    :param codes:              block data (will be resized and re-laid out)
    :type num_vectors: int
    :param num_vectors:        number of vectors in this segment
    :type bbs: int
    :param bbs:                block batch size (vectors per block)
    :type M2: int
    :param M2:                 rounded sub-quantizer count
    :type old_block_stride: int
    :param old_block_stride:   old block size (packed codes only, or current)
    :type new_block_stride: int
    :param new_block_stride:   new block size (packed codes + aux region)
    :type storage_size: int
    :param storage_size:       per-vector aux storage size in bytes
    :type id_map: int, optional
    :param id_map:             maps local offset to global ID; null = sequential

Python Library Documentation: function quantize_LUT_and_bias in module faiss.swigfaiss

quantize_LUT_and_bias(nprobe, M, ksub, lut_is_3d, LUT, bias, LUTq, M2, biasq, a_out=None, b_out=None)
     LUT quantization to uint8 and bias to uint16.

    (nprobe, M, ksub, lut_is_3d) determine the size of the LUT

     LUT input:
     - 2D size (M, ksub): single matrix per probe (lut_is_3d=false)
     - 3D size (nprobe, M, ksub): separate LUT per probe (lut_is_3d=true)
     bias input:
     - nullptr: bias is 0
     - size (nprobe): one bias per probe
     Output:
     - LUTq uint8 version of the LUT (M size is rounded up to M2)
     - biasq (or nullptr): uint16 version of the LUT
     - a, b: scalars to approximate the true distance

Python Library Documentation: function rand in module faiss.extra_wrappers

rand(n, seed=12345)

Python Library Documentation: function rand_perm in module faiss.swigfaiss

rand_perm(perm, n, seed)

Python Library Documentation: function rand_perm_splitmix64 in module faiss.swigfaiss

rand_perm_splitmix64(perm, n, seed)

Python Library Documentation: function rand_smooth_vectors in module faiss.extra_wrappers

rand_smooth_vectors(n, d, seed=1234)

Python Library Documentation: function randint in module faiss.extra_wrappers

randint(n, seed=12345, vmax=None)

Python Library Documentation: function randn in module faiss.extra_wrappers

randn(n, seed=12345)

Python Library Documentation: function range_search_L2sqr in module faiss.swigfaiss

range_search_L2sqr(x, y, d, nx, ny, radius, result, sel=None)
     Return the k nearest neighbors of each of the nx vectors x among the ny
     vector y, w.r.t to max inner product

    :type x: float
    :param x:      query vectors, size nx * d
    :type y: float
    :param y:      database vectors, size ny * d
    :type radius: float
    :param radius: search radius around the x vectors
    :type result: :py:class:`RangeSearchResult`
    :param result: result structure

Python Library Documentation: function range_search_inner_product in module faiss.swigfaiss

range_search_inner_product(x, y, d, nx, ny, radius, result, sel=None)
    same as range_search_L2sqr for the inner product similarity

Python Library Documentation: function range_search_with_parameters in module faiss

range_search_with_parameters(index, x, radius, params=None, output_stats=False)

Python Library Documentation: function range_search_with_parameters in module faiss.swigfaiss

range_search_with_parameters(index, n, x, radius, result, params, nb_dis=None, ms_per_stage=None)
    same as search_with_parameters but for range search

Python Library Documentation: function ranklist_handle_ties in module faiss.swigfaiss

ranklist_handle_ties(k, idx, dis)
    distances are supposed to be sorted. Sorts indices with same distance

Python Library Documentation: function ranklist_intersection_size in module faiss.swigfaiss

ranklist_intersection_size(k1, v1, k2, v2)
     count the number of common elements between v1 and v2
    algorithm = sorting + bisection to avoid double-counting duplicates

Python Library Documentation: function read_InvertedLists in module faiss.swigfaiss

read_InvertedLists(reader, io_flags=0)

Python Library Documentation: function read_ProductQuantizer in module faiss.swigfaiss

read_ProductQuantizer(*args)

Python Library Documentation: function read_VectorTransform in module faiss.swigfaiss

read_VectorTransform(*args)

Python Library Documentation: function read_index in module faiss.swigfaiss

read_index(*args)

Python Library Documentation: function read_index_binary in module faiss.swigfaiss

read_index_binary(*args)

Python Library Documentation: function real_to_binary in module faiss.swigfaiss

real_to_binary(d, x_in, x_out)
     Convert float vector to binary vector. Components > 0 are converted to 1,
    others to 0.

    :type d: int
    :param d:      dimension of the vector (multiple of 8)
    :type x_in: float
    :param x_in:   input float vector (float table of size d)
    :type x_out: uint8_t
    :param x_out:  output binary vector (uint8_t table of size d / 8)

Python Library Documentation: function refine_beam_LUT_mp in module faiss.swigfaiss

refine_beam_LUT_mp(rq, n, query_norms, query_cp, out_beam_size, out_codes, out_distances, pool)

Python Library Documentation: function refine_beam_mp in module faiss.swigfaiss

refine_beam_mp(rq, n, beam_size, x, out_beam_size, out_codes, out_residuals, out_distances, pool)

Python Library Documentation: function reflection in module faiss.swigfaiss

reflection(u, x, n, d, nu)

Python Library Documentation: function rev_swig_ptr in module faiss.swigfaiss

rev_swig_ptr(*args)

Python Library Documentation: function round_uint8_per_column in module faiss.swigfaiss

round_uint8_per_column(tab, n, d, a_out=None, b_out=None)
     Functions to quantize PQ floating-point Look Up Tables (LUT) to uint8, and
    biases to uint16. The accumulation is supposed to take place in uint16.
    The quantization coefficients are float (a, b) such that

         original_value = quantized_value * a / b

    The hardest part of the quantization is with multiple LUTs that need to be
    added up together. In that case, coefficient a has to be chosen so that
    the sum fits in a uint16 accumulator.

Python Library Documentation: function round_uint8_per_column_multi in module faiss.swigfaiss

round_uint8_per_column_multi(tab, m, n, d, a_out=None, b_out=None)

Python Library Documentation: function search_and_return_centroids in module faiss.swigfaiss

search_and_return_centroids(index, n, xin, k, distances, labels, query_centroid_ids, result_centroid_ids)

Python Library Documentation: function search_centroid in module faiss.swigfaiss

search_centroid(index, x, n, centroid_ids)

Python Library Documentation: function search_from_candidate_unbounded in module faiss.swigfaiss

search_from_candidate_unbounded(hnsw, node, qdis, ef, vt, stats)

Python Library Documentation: function search_from_candidates in module faiss.swigfaiss

search_from_candidates(hnsw, qdis, res, candidates, vt, stats, level, nres_in=0, params=None)
    Internal HNSW algorithm helpers. These are not part of the public API; they
    are exposed here only so that unit tests (and a few cross-TU callers such as
    the Panorama search variant) can reach them.

Python Library Documentation: function search_from_candidates_panorama in module faiss.swigfaiss

search_from_candidates_panorama(hnsw, index, qdis, res, candidates, vt, stats, level, nres_in=0, params=None)
    Equivalent to `search_from_candidates`, but applies pruning with progressive
    refinement bounds.
    This is used in `IndexHNSWFlatPanorama` to improve the search performance
    for higher dimensional vectors.

Python Library Documentation: function search_neighbors_to_add in module faiss.swigfaiss

search_neighbors_to_add(hnsw, qdis, results, entry_point, d_entry_point, level, vt, reference_version=False)

Python Library Documentation: function search_with_parameters in module faiss

search_with_parameters(index, x, k, params=None, output_stats=False)

Python Library Documentation: function search_with_parameters in module faiss.swigfaiss

search_with_parameters(index, n, x, k, distances, labels, params, nb_dis=None, ms_per_stage=None)
     search an IndexIVF, possibly embedded in an IndexPreTransform with
    given parameters. This is a way to set the nprobe and get
    statdistics in a thread-safe way.

    Optionally returns (if non-nullptr):
    - nb_dis: number of distances computed
    - ms_per_stage: [0]: preprocessing time
                    [1]: coarse quantization,
                    [2]: list scanning

Python Library Documentation: function serialize_index in module faiss

serialize_index(index, io_flags=0)
    convert an index to a numpy uint8 array

Python Library Documentation: function serialize_index_binary in module faiss

serialize_index_binary(index)
    convert an index to a numpy uint8 array

Python Library Documentation: function set_bit_fastscan in module faiss.swigfaiss

set_bit_fastscan(code, bit_index)
     Set bit value in FastScan code format.
    :type code: uint8_t
    :param code:          FastScan code data to modify
    :type bit_index: int
    :param bit_index:     which bit to set (0 to d-1)

Python Library Documentation: function set_bit_standard in module faiss.swigfaiss

set_bit_standard(code, bit_index)
     Set bit value in standard RaBitQ code format.
    :type code: uint8_t
    :param code:          RaBitQ code data to modify
    :type bit_index: int
    :param bit_index:     which bit to set (0 to d-1)

Python Library Documentation: function set_deserialization_lattice_r2_limit in module faiss.swigfaiss

set_deserialization_lattice_r2_limit(value)

Python Library Documentation: function set_deserialization_loop_limit in module faiss.swigfaiss

set_deserialization_loop_limit(value)

Python Library Documentation: function set_deserialization_vector_byte_limit in module faiss.swigfaiss

set_deserialization_vector_byte_limit(value)

Python Library Documentation: function set_invlist_range in module faiss.swigfaiss

set_invlist_range(index, i0, i1, src)
    Set a subset of inverted lists

Python Library Documentation: function shard_binary_ivf_index_centroids in module faiss.swigfaiss

shard_binary_ivf_index_centroids(*args)

Python Library Documentation: function wrapper in module faiss.class_wrappers

wrapper(*args, **kwargs)

Python Library Documentation: function should_refine_candidate in module faiss.swigfaiss

should_refine_candidate(est_distance, f_error, g_error, threshold, is_similarity)
     Determine whether a candidate should be refined in two-stage search.
    Consolidates the filtering logic for both L2 and IP metrics.

    For L2 (min-heap): uses lower_bound = est_distance - error_adjustment
      - Skip if lower_bound >= threshold (can't beat current worst)
    For IP (max-heap): uses upper_bound = est_distance + error_adjustment
      - Skip if upper_bound <= threshold (can't beat current best)

    :type est_distance: float
    :param est_distance:     Estimated 1-bit distance
    :type f_error: float
    :param f_error:          Database vector error factor
    :type g_error: float
    :param g_error:          Query vector error factor
    :type threshold: float
    :param threshold:        Current heap threshold (worst result in heap)
    :type is_similarity: boolean
    :param is_similarity:    True for IP metric (max-heap), false for L2
        (min-heap)
    :rtype: boolean
    :return: True if candidate should be refined with full
        multi-bit distance

Python Library Documentation: function simd_histogram_16 in module faiss.swigfaiss

simd_histogram_16(data, n, min, shift, hist)
    same for 16-bin histogram

Python Library Documentation: function simd_histogram_8 in module faiss.swigfaiss

simd_histogram_8(data, n, min, shift, hist)
     low level SIMD histogramming functions  8-bin histogram of (x - min) >> shift
    values outside the range are ignored.
    the data table should be aligned on 32 bytes

Python Library Documentation: int object

class int(object)
 |  int([x]) -> 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
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __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__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __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
 |
 |  __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__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      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.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        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.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        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.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  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

Python Library Documentation: function smawk in module faiss.swigfaiss

smawk(nrows, ncols, x, argmins)
     SMAWK algorithm. Find the row minima of a monotone matrix.

    Expose this for testing.

    :type nrows: int
    :param nrows:    number of rows
    :type ncols: int
    :param ncols:    number of columns
    :type x: float
    :param x:        input matrix, size (nrows, ncols)
    :type argmins: int
    :param argmins:  argmin of each row

Python Library Documentation: function storage_distance_computer in module faiss.swigfaiss

storage_distance_computer(storage)

Python Library Documentation: module subprocess

NAME
    subprocess - Subprocesses with accessible I/O streams

MODULE REFERENCE
    https://docs.python.org/3.12/library/subprocess.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module allows you to spawn processes, connect to their
    input/output/error pipes, and obtain their return codes.

    For a complete description of this module see the Python documentation.

    Main API
    ========
    run(...): Runs a command, waits for it to complete, then returns a
              CompletedProcess instance.
    Popen(...): A class for flexibly executing a command in a new process

    Constants
    ---------
    DEVNULL: Special value that indicates that os.devnull should be used
    PIPE:    Special value that indicates a pipe should be created
    STDOUT:  Special value that indicates that stderr should go to stdout


    Older API
    =========
    call(...): Runs a command, waits for it to complete, then returns
        the return code.
    check_call(...): Same as call() but raises CalledProcessError()
        if return code is not 0
    check_output(...): Same as check_call() but returns the contents of
        stdout instead of a return code
    getoutput(...): Runs a command in the shell, waits for it to complete,
        then returns the output
    getstatusoutput(...): Runs a command in the shell, waits for it to complete,
        then returns a (exitcode, output) tuple

CLASSES
    builtins.Exception(builtins.BaseException)
        SubprocessError
            CalledProcessError
            TimeoutExpired
    builtins.object
        CompletedProcess
        Popen
        STARTUPINFO

    class CalledProcessError(SubprocessError)
     |  CalledProcessError(returncode, cmd, output=None, stderr=None)
     |
     |  Raised when run() is called with check=True and the process
     |  returns a non-zero exit status.
     |
     |  Attributes:
     |    cmd, returncode, stdout, stderr, output
     |
     |  Method resolution order:
     |      CalledProcessError
     |      SubprocessError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, returncode, cmd, output=None, stderr=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  stdout
     |      Alias for output attribute, to match stderr
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SubprocessError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  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 CompletedProcess(builtins.object)
     |  CompletedProcess(args, returncode, stdout=None, stderr=None)
     |
     |  A process that has finished running.
     |
     |  This is returned by run().
     |
     |  Attributes:
     |    args: The list or str args passed to run().
     |    returncode: The exit code of the process, negative for signals.
     |    stdout: The standard output (None if not captured).
     |    stderr: The standard error (None if not captured).
     |
     |  Methods defined here:
     |
     |  __init__(self, args, returncode, stdout=None, stderr=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  check_returncode(self)
     |      Raise CalledProcessError if the exit code is non-zero.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__ = GenericAlias(...)
     |      Represent a PEP 585 generic type
     |
     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Popen(builtins.object)
     |  Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, user=None, group=None, extra_groups=None, encoding=None, errors=None, text=None, umask=-1, pipesize=-1, process_group=None)
     |
     |  Execute a child program in a new process.
     |
     |  For a complete description of the arguments see the Python documentation.
     |
     |  Arguments:
     |    args: A string, or a sequence of program arguments.
     |
     |    bufsize: supplied as the buffering argument to the open() function when
     |        creating the stdin/stdout/stderr pipe file objects
     |
     |    executable: A replacement program to execute.
     |
     |    stdin, stdout and stderr: These specify the executed programs' standard
     |        input, standard output and standard error file handles, respectively.
     |
     |    preexec_fn: (POSIX only) An object to be called in the child process
     |        just before the child is executed.
     |
     |    close_fds: Controls closing or inheriting of file descriptors.
     |
     |    shell: If true, the command will be executed through the shell.
     |
     |    cwd: Sets the current directory before the child is executed.
     |
     |    env: Defines the environment variables for the new process.
     |
     |    text: If true, decode stdin, stdout and stderr using the given encoding
     |        (if set) or the system default otherwise.
     |
     |    universal_newlines: Alias of text, provided for backwards compatibility.
     |
     |    startupinfo and creationflags (Windows only)
     |
     |    restore_signals (POSIX only)
     |
     |    start_new_session (POSIX only)
     |
     |    process_group (POSIX only)
     |
     |    group (POSIX only)
     |
     |    extra_groups (POSIX only)
     |
     |    user (POSIX only)
     |
     |    umask (POSIX only)
     |
     |    pass_fds (POSIX only)
     |
     |    encoding and errors: Text mode encoding and error handling to use for
     |        file objects stdin, stdout and stderr.
     |
     |  Attributes:
     |      stdin, stdout, stderr, pid, returncode
     |
     |  Methods defined here:
     |
     |  __del__(self, _maxsize=9223372036854775807, _warn=<built-in function warn>)
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, value, traceback)
     |
     |  __init__(self, args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, user=None, group=None, extra_groups=None, encoding=None, errors=None, text=None, umask=-1, pipesize=-1, process_group=None)
     |      Create new Popen instance.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  communicate(self, input=None, timeout=None)
     |      Interact with process: Send data to stdin and close it.
     |      Read data from stdout and stderr, until end-of-file is
     |      reached.  Wait for process to terminate.
     |
     |      The optional "input" argument should be data to be sent to the
     |      child process, or None, if no data should be sent to the child.
     |      communicate() returns a tuple (stdout, stderr).
     |
     |      By default, all communication is in bytes, and therefore any
     |      "input" should be bytes, and the (stdout, stderr) will be bytes.
     |      If in text mode (indicated by self.text_mode), any "input" should
     |      be a string, and (stdout, stderr) will be strings decoded
     |      according to locale encoding, or by "encoding" if set. Text mode
     |      is triggered by setting any of text, encoding, errors or
     |      universal_newlines.
     |
     |  kill = terminate(self)
     |
     |  poll(self)
     |      Check if child process has terminated. Set and return returncode
     |      attribute.
     |
     |  send_signal(self, sig)
     |      Send a signal to the process.
     |
     |  terminate(self)
     |      Terminates the process.
     |
     |  wait(self, timeout=None)
     |      Wait for child process to terminate; returns self.returncode.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __class_getitem__ = GenericAlias(...)
     |      Represent a PEP 585 generic type
     |
     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  universal_newlines

    class STARTUPINFO(builtins.object)
     |  STARTUPINFO(*, dwFlags=0, hStdInput=None, hStdOutput=None, hStdError=None, wShowWindow=0, lpAttributeList=None)
     |
     |  Methods defined here:
     |
     |  __init__(self, *, dwFlags=0, hStdInput=None, hStdOutput=None, hStdError=None, wShowWindow=0, lpAttributeList=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  copy(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SubprocessError(builtins.Exception)
     |  # Exception classes used by this module.
     |
     |  Method resolution order:
     |      SubprocessError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  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 TimeoutExpired(SubprocessError)
     |  TimeoutExpired(cmd, timeout, output=None, stderr=None)
     |
     |  This exception is raised when the timeout expires while waiting for a
     |  child process.
     |
     |  Attributes:
     |      cmd, output, stdout, stderr, timeout
     |
     |  Method resolution order:
     |      TimeoutExpired
     |      SubprocessError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, cmd, timeout, output=None, stderr=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  stdout
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SubprocessError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  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

FUNCTIONS
    call(*popenargs, timeout=None, **kwargs)
        Run command with arguments.  Wait for command to complete or
        timeout, then return the returncode attribute.

        The arguments are the same as for the Popen constructor.  Example:

        retcode = call(["ls", "-l"])

    check_call(*popenargs, **kwargs)
        Run command with arguments.  Wait for command to complete.  If
        the exit code was zero then return, otherwise raise
        CalledProcessError.  The CalledProcessError object will have the
        return code in the returncode attribute.

        The arguments are the same as for the call function.  Example:

        check_call(["ls", "-l"])

    check_output(*popenargs, timeout=None, **kwargs)
        Run command with arguments and return its output.

        If the exit code was non-zero it raises a CalledProcessError.  The
        CalledProcessError object will have the return code in the returncode
        attribute and output in the output attribute.

        The arguments are the same as for the Popen constructor.  Example:

        >>> check_output(["ls", "-l", "/dev/null"])
        b'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'

        The stdout argument is not allowed as it is used internally.
        To capture standard error in the result, use stderr=STDOUT.

        >>> check_output(["/bin/sh", "-c",
        ...               "ls -l non_existent_file ; exit 0"],
        ...              stderr=STDOUT)
        b'ls: non_existent_file: No such file or directory\n'

        There is an additional optional argument, "input", allowing you to
        pass a string to the subprocess's stdin.  If you use this argument
        you may not also use the Popen constructor's "stdin" argument, as
        it too will be used internally.  Example:

        >>> check_output(["sed", "-e", "s/foo/bar/"],
        ...              input=b"when in the course of fooman events\n")
        b'when in the course of barman events\n'

        By default, all communication is in bytes, and therefore any "input"
        should be bytes, and the return value will be bytes.  If in text mode,
        any "input" should be a string, and the return value will be a string
        decoded according to locale encoding, or by "encoding" if set. Text mode
        is triggered by setting any of text, encoding, errors or universal_newlines.

    getoutput(cmd, *, encoding=None, errors=None)
        Return output (stdout or stderr) of executing cmd in a shell.

        Like getstatusoutput(), except the exit status is ignored and the return
        value is a string containing the command's output.  Example:

        >>> import subprocess
        >>> subprocess.getoutput('ls /bin/ls')
        '/bin/ls'

    getstatusoutput(cmd, *, encoding=None, errors=None)
        Return (exitcode, output) of executing cmd in a shell.

        Execute the string 'cmd' in a shell with 'check_output' and
        return a 2-tuple (status, output). The locale encoding is used
        to decode the output and process newlines.

        A trailing newline is stripped from the output.
        The exit status for the command can be interpreted
        according to the rules for the function 'wait'. Example:

        >>> import subprocess
        >>> subprocess.getstatusoutput('ls /bin/ls')
        (0, '/bin/ls')
        >>> subprocess.getstatusoutput('cat /bin/junk')
        (1, 'cat: /bin/junk: No such file or directory')
        >>> subprocess.getstatusoutput('/bin/junk')
        (127, 'sh: /bin/junk: not found')
        >>> subprocess.getstatusoutput('/bin/kill $$')
        (-15, '')

    run(*popenargs, input=None, capture_output=False, timeout=None, check=False, **kwargs)
        Run command with arguments and return a CompletedProcess instance.

        The returned instance will have attributes args, returncode, stdout and
        stderr. By default, stdout and stderr are not captured, and those attributes
        will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them,
        or pass capture_output=True to capture both.

        If check is True and the exit code was non-zero, it raises a
        CalledProcessError. The CalledProcessError object will have the return code
        in the returncode attribute, and output & stderr attributes if those streams
        were captured.

        If timeout is given, and the process takes too long, a TimeoutExpired
        exception will be raised.

        There is an optional argument "input", allowing you to
        pass bytes or a string to the subprocess's stdin.  If you use this argument
        you may not also use the Popen constructor's "stdin" argument, as
        it will be used internally.

        By default, all communication is in bytes, and therefore any "input" should
        be bytes, and the stdout and stderr will be bytes. If in text mode, any
        "input" should be a string, and stdout and stderr will be strings decoded
        according to locale encoding, or by "encoding" if set. Text mode is
        triggered by setting any of text, encoding, errors or universal_newlines.

        The other arguments are the same as for the Popen constructor.

DATA
    ABOVE_NORMAL_PRIORITY_CLASS = 32768
    BELOW_NORMAL_PRIORITY_CLASS = 16384
    CREATE_BREAKAWAY_FROM_JOB = 16777216
    CREATE_DEFAULT_ERROR_MODE = 67108864
    CREATE_NEW_CONSOLE = 16
    CREATE_NEW_PROCESS_GROUP = 512
    CREATE_NO_WINDOW = 134217728
    DETACHED_PROCESS = 8
    DEVNULL = -3
    HIGH_PRIORITY_CLASS = 128
    IDLE_PRIORITY_CLASS = 64
    NORMAL_PRIORITY_CLASS = 32
    PIPE = -1
    REALTIME_PRIORITY_CLASS = 256
    STARTF_USESHOWWINDOW = 1
    STARTF_USESTDHANDLES = 256
    STDOUT = -2
    STD_ERROR_HANDLE = 4294967284
    STD_INPUT_HANDLE = 4294967286
    STD_OUTPUT_HANDLE = 4294967285
    SW_HIDE = 0
    __all__ = ['Popen', 'PIPE', 'STDOUT', 'call', 'check_call', 'getstatus...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\subprocess.py

Python Library Documentation: function supported_instruction_sets in module faiss.loader

supported_instruction_sets()
    Returns the set of supported CPU features, see
    https://github.com/numpy/numpy/blob/master/numpy/core/src/common/npy_cpu_features.h
    for the list of features that this set may contain per architecture.

    Example:
    >>> supported_instruction_sets()  # for x86
    {"SSE2", "AVX2", "AVX512", ...}
    >>> supported_instruction_sets()  # for PPC
    {"VSX", "VSX2", ...}
    >>> supported_instruction_sets()  # for ARM
    {"NEON", "ASIMD", ...}

Python Library Documentation: function swig_ptr in module faiss.swigfaiss

swig_ptr(a)

Python Library Documentation: function swig_version in module faiss.swigfaiss

swig_version()

Python Library Documentation: module faiss.swigfaiss in faiss

NAME
    faiss.swigfaiss

DESCRIPTION
    # This file was automatically generated by SWIG (https://www.swig.org).
    # Version 4.4.1
    #
    # Do not make changes to this file unless you know what you are doing - modify
    # the SWIG interface file instead.

CLASSES
    builtins.object
        AlignedTableFloat32
        AlignedTableUint16
        AlignedTableUint8
        AutoTuneCriterion
            IntersectionCriterion
            OneRecallAtRCriterion
        BinaryInvertedListScanner
        BitstringReader
        BitstringWriter
        BufferList
            RangeSearchPartialResult
        Cloner
        ClusteringInitialization
        ClusteringIterationStats
        ClusteringIterationStatsVector
        ClusteringParameters
            Clustering
                Clustering1D
            ProgressiveDimClusteringParameters
                ProgressiveDimClustering
            SuperKMeansParameters
        CodePacker
            CodePackerFlat
        CodeSet
        CombinerRangeKNNfloat
        CombinerRangeKNNint16
        ComputeCodesAddCentroidsLUT0MemoryPool
        ComputeCodesAddCentroidsLUT1MemoryPool
        DirectMap
        DirectMapAdd
        DistanceComputer
            FlatCodesDistanceComputer
                RaBitQDistanceComputer
            NegativeDistanceComputer
        Embedding
        EnumeratedVectors
            ZnSphereCodecRec
        ExtraBitsFactors
        FFN
        FastScanDistancePostProcessing
        FastScanStats
        Float32Vector
        Float32VectorVector
        Float64Vector
        HNSW
        HNSWStats
        IDSelector
            IDSelectorAll
            IDSelectorAnd
            IDSelectorArray
            IDSelectorBatch
            IDSelectorBitmap
            IDSelectorNot
            IDSelectorOr
            IDSelectorRange
            IDSelectorTranslated
            IDSelectorXOr
            PyCallbackIDSelector
        IOReader
            BufferedIOReader
            FileIOReader
            MappedFileIOReader
            PyCallbackIOReader
            VectorIOReader
            ZeroCopyIOReader
        IOWriter
            BufferedIOWriter
            FileIOWriter
            PyCallbackIOWriter
            VectorIOWriter
        IVFFastScanStats
        IcmEncoder
        IcmEncoderFactory
        Index
            AdditiveCoarseQuantizer
                LocalSearchCoarseQuantizer
                ResidualCoarseQuantizer
            IndexFastScan
                IndexAdditiveQuantizerFastScan
                    IndexLocalSearchQuantizerFastScan
                    IndexProductLocalSearchQuantizerFastScan
                    IndexProductResidualQuantizerFastScan
                    IndexResidualQuantizerFastScan
                IndexPQFastScan
                IndexRaBitQFastScan
            IndexFlatCodes
                Index2Layer
                IndexAdditiveQuantizer
                    IndexLocalSearchQuantizer
                    IndexProductLocalSearchQuantizer
                    IndexProductResidualQuantizer
                    IndexResidualQuantizer
                IndexFlat
                    IndexFlatIP
                    IndexFlatL2
                        IndexFlat1D
                    IndexFlatPanorama
                        IndexFlatIPPanorama
                        IndexFlatL2Panorama
                IndexLSH
                IndexLattice
                IndexNeuralNetCodec
                    IndexQINCo
                IndexPQ
                IndexRaBitQ
                IndexScalarQuantizer
            IndexHNSW
                IndexHNSW2Level
                IndexHNSWCagra
                IndexHNSWFlat
                    IndexHNSWFlatPanorama
                IndexHNSWPQ
                IndexHNSWSQ
            IndexIDMap
                IndexIDMap2
            IndexIVF(Index, IndexIVFInterface)
                IndexIVFAdditiveQuantizer
                    IndexIVFLocalSearchQuantizer
                    IndexIVFProductLocalSearchQuantizer
                    IndexIVFProductResidualQuantizer
                    IndexIVFResidualQuantizer
                IndexIVFFastScan
                    IndexIVFAdditiveQuantizerFastScan
                        IndexIVFLocalSearchQuantizerFastScan
                        IndexIVFProductLocalSearchQuantizerFastScan
                        IndexIVFProductResidualQuantizerFastScan
                        IndexIVFResidualQuantizerFastScan
                    IndexIVFPQFastScan
                    IndexIVFRaBitQFastScan
                IndexIVFFlat
                    IndexIVFFlatDedup
                    IndexIVFFlatPanorama
                IndexIVFPQ
                    IndexIVFPQR
                IndexIVFRaBitQ
                IndexIVFScalarQuantizer
                IndexIVFSpectralHash
            IndexIVFIndependentQuantizer
            IndexNNDescent
                IndexNNDescentFlat
            IndexNSG
                IndexNSGFlat
                IndexNSGPQ
                IndexNSGSQ
            IndexPreTransform
            IndexRandom
            IndexRefine
                IndexRefineFlat
                IndexRefinePanorama
            IndexRowwiseMinMaxBase
                IndexRowwiseMinMax
                IndexRowwiseMinMaxFP16
            IndexSplitVectors
            MultiIndexQuantizer
                MultiIndexQuantizer2
            ThreadedIndexBase
                IndexReplicas
                IndexShards
                    IndexShardsIVF(IndexShards, Level1Quantizer)
        IndexBinary
            IndexBinaryFlat
            IndexBinaryFromFloat
            IndexBinaryHNSW
                IndexBinaryHNSWCagra
            IndexBinaryHash
            IndexBinaryIDMap
                IndexBinaryIDMap2
            IndexBinaryIVF
            IndexBinaryMultiHash
            ThreadedIndexBaseBinary
                IndexBinaryReplicas
                IndexBinaryShards
        IndexBinaryHashStats
        IndexIVFPQStats
        IndexIVFStats
        IndexPQStats
        Int16Vector
        Int32Tensor2D
        Int32Vector
        Int32VectorVector
        Int64Vector
        Int64VectorVector
        Int8Vector
        InterruptCallback
            PythonInterruptCallback
            TimeoutCallback
        InvertedListScanner
        InvertedListScannerStats
        InvertedLists
            ArrayInvertedLists
                ArrayInvertedListsPanorama
            BlockInvertedLists
            CappedInvertedLists
            ReadOnlyInvertedLists
                HStackInvertedLists
                MaskedInvertedLists
                SliceInvertedLists
                StopWordsInvertedLists
                VStackInvertedLists
        InvertedListsIOHook
        InvertedListsIterator
        InvertedListsPtrVector
        LSQTimer
        LSQTimerScope
        Level1Quantizer
            IndexIVFInterface
        Linear
        MapLong2Long
        MatrixStats
        MaybeOwnedVectorFloat32
        MaybeOwnedVectorFloat32Vector
        MaybeOwnedVectorInt32
        MaybeOwnedVectorInt32Vector
        MaybeOwnedVectorOwner
            MmappedFileMappingOwner
        MaybeOwnedVectorUInt8
        MaybeOwnedVectorUInt8Vector
        NNDescent
        NSG
        NSG_Graph_int
        Neighbor
        NeuralNetCodec
            QINCo
        Nhood
        OperatingPoint
        OperatingPointVector
        OperatingPoints
        PQDecoder16
        PQDecoder8
        PQDecoderGeneric
        PQEncoder16
        PQEncoder8
        PQEncoderGeneric
        Panorama
        PanoramaStats
        ParameterRange
        ParameterRangeVector
        ParameterSpace
        PartitionStats
        PermutationObjective
            ReproduceDistancesObjective
        ProgressiveDimIndexFactory
        QINCoStep
        Quantizer
            AdditiveQuantizer
                LocalSearchQuantizer
                ProductAdditiveQuantizer
                    ProductLocalSearchQuantizer
                    ProductResidualQuantizer
                ResidualQuantizer
            ProductQuantizer
            RaBitQuantizer
            ScalarQuantizer
        QueryFactorsData
        RandomGenerator
        RangeQueryResult
        RangeSearchResult
        RefineBeamLUTMemoryPool
        RefineBeamMemoryPool
        Repeat
        RepeatVector
        Repeats
        SIMDConfig
        SearchParameters
            IndexRefineSearchParameters
            RaBitQSearchParameters
            SearchParametersHNSW
            SearchParametersIVF
                IVFPQSearchParameters
                IVFRaBitQSearchParameters
                IVFSQTurboQSearchParameters
            SearchParametersPQ
            SearchParametersPreTransform
            SearchParametersResidualCoarseQuantizer
        ShardingFunction
            DefaultShardingFunction
            PyCallbackShardingFunction
        SignBitFactors
            SignBitFactorsWithError
        SimulatedAnnealingParameters
            PolysemousTraining
            SimulatedAnnealingOptimizer
        SlidingIndexWindow
        SplitMix64RandomGenerator
        SuperKMeans
        SwigPyIterator
        Tensor2D
        UInt16Vector
        UInt32Vector
        UInt64Vector
        UInt8Vector
        UInt8VectorVector
        VectorTransform
            CenteringTransform
            HadamardRotation
            ITQTransform
            LinearTransform
                ITQMatrix
                OPQMatrix
                PCAMatrix
                RandomRotationMatrix
            NormalizationTransform
            RemapDimensionsTransform
        VectorTransformVector
        VisitedTable
            VisitedTableSet
            VisitedTableVector
        ZnSphereSearch
            ZnSphereCodec(ZnSphereSearch, EnumeratedVectors)
                ZnSphereCodecAlt
        float_maxheap_array_t
        float_minheap_array_t
        int_maxheap_array_t
        int_minheap_array_t

    class AdditiveCoarseQuantizer(Index)
     |  AdditiveCoarseQuantizer(*args)
     |
     |   A "virtual" index where the elements are the residual quantizer centroids.
     |
     |  Intended for use as a coarse quantizer in an IndexIVF.
     |
     |  Method resolution order:
     |      AdditiveCoarseQuantizer
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      N/A
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids) from Index
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from Index
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1) from Index
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from Index
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons) from Index
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from Index
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from Index
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  reset(self)
     |      N/A
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from Index
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from Index
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None) from Index
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_AdditiveCoarseQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  aq
     |
     |  centroid_norms
     |      norms of centroids, useful for knn-search
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class AdditiveQuantizer(Quantizer)
     |  AdditiveQuantizer(*args, **kwargs)
     |
     |   Abstract structure for additive quantizers
     |
     |  Different from the product quantizer in which the decoded vector is the
     |  concatenation of M sub-vectors, additive quantizers sum M sub-vectors
     |  to get the decoded vector.
     |
     |  Method resolution order:
     |      AdditiveQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
     |       Compute inner-product look-up tables. Used in the centroid search
     |      functions.
     |
     |      :type xq: float
     |      :param xq:     query vector, size (n, d)
     |      :type LUT: float
     |      :param LUT:    look-up table, size (n, total_codebook_size)
     |      :type alpha: float, optional
     |      :param alpha:  compute alpha * inner-product
     |      :type ld_lut: int, optional
     |      :param ld_lut:  leading dimension of LUT
     |
     |  compute_centroid_norms(self, norms)
     |       For L2 search we need the L2 norms of the centroids
     |
     |      :type norms: float
     |      :param norms:    output norms table, size total_codebook_size
     |
     |  compute_codebook_tables(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |      :type centroids: float, optional
     |      :param centroids:  centroids to be added to x, size n * d
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_64bit(self, n, x)
     |      decoding function for a code in a 64-bit word
     |
     |  decode_c = decode(self, codes, x, n)
     |       Decode a set of vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  decode_qcint(self, c)
     |      decode norm by non-uniform scalar quantization
     |
     |  decode_unpacked(self, codes, x, n, ld_codes=-1)
     |       Decode a set of vectors in non-packed format
     |
     |      :type codes: int
     |      :param codes:  codes to decode, size n * ld_codes
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  encode_norm(self, norm)
     |      encode a norm into norm_bits bits
     |
     |  encode_qcint(self, x)
     |      encode norm by non-uniform scalar quantization
     |
     |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
     |      Exact L2 search, with precomputed norms
     |
     |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
     |      exact IP search
     |
     |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
     |       pack a series of code to bit-compact format
     |
     |      :type codes: int
     |      :param codes:        codes to be packed, size n * code_size
     |      :type packed_codes: uint8_t
     |      :param packed_codes: output bit-compact codes
     |      :type ld_codes: int, optional
     |      :param ld_codes:     leading dimension of codes
     |      :type norms: float, optional
     |      :param norms:        norms of the vectors (size n). Will be computed if
     |                              needed but not provided
     |      :type centroids: float, optional
     |      :param centroids:    centroids to be added to x, size n * d
     |
     |  set_derived_values(self)
     |      Train the norm quantizer
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x) from Quantizer
     |       Train the quantizer
     |
     |      :type x: float
     |      :param x:       training vectors, size n * d
     |
     |  train_norm(self, n, norms)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_AdditiveQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |      number of codebooks
     |
     |  centroid_norms
     |      norms of all codebook entries (size total_codebook_size)
     |
     |  codebook_cross_products
     |      dot products of all codebook entries with the previous codebooks
     |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
     |
     |  codebook_offsets
     |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
     |      in the codebooks table of size total_codebook_size by d
     |
     |  codebooks
     |      codebooks
     |
     |  is_trained
     |      is trained or not
     |
     |  max_mem_distances
     |      norms and distance matrixes with beam search can get large, so use this
     |      to control for the amount of memory that can be allocated
     |
     |  nbits
     |      bits for each step
     |
     |  norm_bits
     |      bits allocated for the norms
     |
     |  norm_max
     |
     |  norm_min
     |      min/max for quantization of norms
     |
     |  norm_tabs
     |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
     |      store norms of codebook entries for 4-bit fastscan
     |
     |  only_8bit
     |      are all nbits = 8 (use faster decoder)
     |
     |  qnorm
     |      store and search norms
     |
     |  search_type
     |      Also determines what's in the codes
     |
     |  thisown
     |      The membership flag
     |
     |  tot_bits
     |      total number of bits (indexes + norms)
     |
     |  total_codebook_size
     |      size of the codebook in vectors
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  ST_LUT_nonorm = 1
     |
     |  ST_count = 10
     |
     |  ST_decompress = 0
     |
     |  ST_norm_cqint4 = 7
     |
     |  ST_norm_cqint8 = 6
     |
     |  ST_norm_float = 3
     |
     |  ST_norm_from_LUT = 2
     |
     |  ST_norm_lsq2x4 = 8
     |
     |  ST_norm_qint4 = 5
     |
     |  ST_norm_qint8 = 4
     |
     |  ST_norm_rq2x4 = 9
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class AlignedTableFloat32(builtins.object)
     |  AlignedTableFloat32(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clear(self)
     |
     |  data(self, *args)
     |
     |  get(self, *args)
     |
     |  itemsize(self)
     |
     |  nbytes(self)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_AlignedTableFloat32(...)
     |
     |  round_capacity(n)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  numel
     |
     |  tab
     |
     |  thisown
     |      The membership flag

    class AlignedTableUint16(builtins.object)
     |  AlignedTableUint16(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clear(self)
     |
     |  data(self, *args)
     |
     |  get(self, *args)
     |
     |  itemsize(self)
     |
     |  nbytes(self)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_AlignedTableUint16(...)
     |
     |  round_capacity(n)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  numel
     |
     |  tab
     |
     |  thisown
     |      The membership flag

    class AlignedTableUint8(builtins.object)
     |  AlignedTableUint8(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clear(self)
     |
     |  data(self, *args)
     |
     |  get(self, *args)
     |
     |  itemsize(self)
     |
     |  nbytes(self)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_AlignedTableUint8(...)
     |
     |  round_capacity(n)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  numel
     |
     |  tab
     |
     |  thisown
     |      The membership flag

    class ArrayInvertedLists(InvertedLists)
     |  ArrayInvertedLists(nlist_in, code_size_in)
     |
     |  simple (default) implementation as an array of inverted lists
     |
     |  Method resolution order:
     |      ArrayInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, nlist_in, code_size_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  permute_invlists(self, map)
     |      permute the inverted lists, map maps new_id to old_id
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ArrayInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  codes
     |
     |  ids
     |      Inverted lists for indexes
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class ArrayInvertedListsPanorama(ArrayInvertedLists)
     |  ArrayInvertedListsPanorama(*args)
     |
     |  Level-oriented storage as defined in the IVFFlat section of Panorama
     |  (https://www.arxiv.org/pdf/2510.00566).
     |
     |  Method resolution order:
     |      ArrayInvertedListsPanorama
     |      ArrayInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  get_cum_sums(self, list_no)
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      Panorama's layout make it impractical to support iterators as defined
     |      by Faiss (i.e. `InvertedListsIterator` API). The iterator would require
     |      to allocate and reassemble the vector at each call.
     |      Hence, we override this method to throw an error, this effectively
     |      disables the `iterate_codes` and `iterate_codes_range` methods.
     |
     |  get_single_code(self, list_no, offset)
     |      Reconstructs a single code from level-oriented storage to flat format.
     |
     |  release_codes(self, list_no, codes_in)
     |      Frees codes returned by `get_single_code`.
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ArrayInvertedListsPanorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  level_width
     |
     |  n_levels
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  cum_sums
     |
     |  pano
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ArrayInvertedLists:
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  permute_invlists(self, map)
     |      permute the inverted lists, map maps new_id to old_id
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ArrayInvertedLists:
     |
     |  codes
     |
     |  ids
     |      Inverted lists for indexes
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class AutoTuneCriterion(builtins.object)
     |  AutoTuneCriterion(*args, **kwargs)
     |
     |  Evaluation criterion. Returns a performance measure in [0,1],
     |  higher is better.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  evaluate = replacement_evaluate(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
     |
     |  evaluate_c = evaluate(self, D, I)
     |       Evaluate the criterion.
     |
     |      :type D: float
     |      :param D:  size nq * nnn
     |      :type I: int
     |      :param I:  size nq * nnn
     |      :rtype: float
     |      :return: the criterion, between 0 and 1. Larger is better.
     |
     |  set_groundtruth = replacement_set_groundtruth(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
     |
     |  set_groundtruth_c = set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
     |       Initializes the gt_D and gt_I vectors. Must be called before evaluating
     |
     |      :type gt_D_in: float
     |      :param gt_D_in:  size nq * gt_nnn
     |      :type gt_I_in: int
     |      :param gt_I_in:  size nq * gt_nnn
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_AutoTuneCriterion(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  gt_D
     |      Ground-truth distances (size nq * gt_nnn)
     |
     |  gt_I
     |      Ground-truth indexes (size nq * gt_nnn)
     |
     |  gt_nnn
     |      nb of GT NNs required to evaluate criterion
     |
     |  nnn
     |      nb of NNs that the query should request
     |
     |  nq
     |      nb of queries this criterion is evaluated on
     |
     |  thisown
     |      The membership flag

    class BinaryInvertedListScanner(builtins.object)
     |  BinaryInvertedListScanner(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  distance_to_code(self, code)
     |      compute a single query-to-code distance
     |
     |  scan_codes(self, n, codes, ids, distances, labels, k)
     |       compute the distances to codes. (distances, labels) should be
     |      organized as a min- or max-heap
     |
     |      :type n: int
     |      :param n:      number of codes to scan
     |      :type codes: uint8_t
     |      :param codes:  codes to scan (n * code_size)
     |      :type ids: int
     |      :param ids:        corresponding ids (ignored if store_pairs)
     |      :type distances: int
     |      :param distances:  heap distances (size k)
     |      :type labels: int
     |      :param labels:     heap labels (size k)
     |      :type k: int
     |      :param k:          heap size
     |
     |  scan_codes_range(self, n, codes, ids, radius, result)
     |
     |  set_list(self, list_no, coarse_dis)
     |      following codes come from this inverted list
     |
     |  set_query(self, query_vector)
     |      from now on we handle this query.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BinaryInvertedListScanner(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class BitstringReader(builtins.object)
     |  BitstringReader(code, code_size)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, code_size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  read(self, nbit)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BitstringReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  code_size
     |
     |  i
     |
     |  thisown
     |      The membership flag

    class BitstringWriter(builtins.object)
     |  BitstringWriter(code, code_size)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, code_size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  write(self, x, nbit)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BitstringWriter(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  code_size
     |
     |  i
     |
     |  thisown
     |      The membership flag

    class BlockInvertedLists(InvertedLists)
     |  BlockInvertedLists(*args)
     |
     |   Inverted Lists that are organized by blocks.
     |
     |  Different from the regular inverted lists, the codes are organized by blocks
     |  of size block_size bytes that represent a set of n_per_block. Therefore, code
     |  allocations are always rounded up to block_size bytes. The codes are also
     |  aligned on 32-byte boundaries for use with SIMD.
     |
     |  To avoid misinterpretations, the code_size is set to (size_t)(-1), even if
     |  arguably the amount of memory consumed by code is block_size / n_per_block.
     |
     |  The writing functions add_entries and update_entries operate on block-aligned
     |  data.
     |
     |  Method resolution order:
     |      BlockInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  remove_ids(self, sel)
     |      remove ids from the InvertedLists
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |      not implemented
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BlockInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  block_size
     |
     |  codes
     |
     |  ids
     |
     |  n_per_block
     |
     |  packer
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class BufferList(builtins.object)
     |  BufferList(buffer_size)
     |
     |  List of temporary buffers used to store results before they are
     |  copied to the RangeSearchResult object.
     |
     |  Methods defined here:
     |
     |  __init__(self, buffer_size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, id, dis)
     |      add one result, possibly appending a new buffer if needed
     |
     |  append_buffer(self)
     |      create a new buffer
     |
     |  copy_range(self, ofs, n, dest_ids, dest_dis)
     |      copy elements ofs:ofs+n-1 seen as linear data in the buffers to
     |      tables dest_ids, dest_dis
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BufferList(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  buffer_size
     |
     |  buffers
     |
     |  thisown
     |      The membership flag
     |
     |  wp
     |      write pointer in the last buffer.

    class BufferedIOReader(IOReader)
     |  BufferedIOReader(*args)
     |
     |  wraps an ioreader to make buffered reads to avoid too small reads
     |
     |  Method resolution order:
     |      BufferedIOReader
     |      IOReader
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BufferedIOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  b0
     |      range of available bytes in the buffer
     |
     |  b1
     |
     |  bsz
     |
     |  buffer
     |
     |  ofs
     |      offset in input stream
     |
     |  ofs2
     |      number of bytes returned to caller
     |
     |  reader
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOReader:
     |
     |  filedescriptor(self)
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOReader:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class BufferedIOWriter(IOWriter)
     |  BufferedIOWriter(*args)
     |
     |  Method resolution order:
     |      BufferedIOWriter
     |      IOWriter
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_BufferedIOWriter(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  b0
     |      amount of data in buffer
     |
     |  bsz
     |
     |  buffer
     |
     |  ofs
     |
     |  ofs2
     |      number of bytes received from caller
     |
     |  thisown
     |      The membership flag
     |
     |  writer
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOWriter:
     |
     |  filedescriptor(self)
     |
     |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOWriter:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class CappedInvertedLists(InvertedLists)
     |  CappedInvertedLists(il, maxsize)
     |
     |  Cap list sizes to maxsize for searching, while allowing writes.
     |  Unlike StopWordsInvertedLists which skips large lists entirely,
     |  this caps each list to maxsize entries (partial scan).
     |
     |  Method resolution order:
     |      CappedInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, il, maxsize)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  prefetch_lists(self, list_nos, nlist)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  real_list_size(self, list_no)
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CappedInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  il0
     |
     |  maxsize
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class CenteringTransform(VectorTransform)
     |  CenteringTransform(d=0)
     |
     |  Subtract the mean of each component from the vectors.
     |
     |  Method resolution order:
     |      CenteringTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, d=0)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |      subtract the mean
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      add the mean
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |      train on n vectors.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CenteringTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  mean
     |      Mean, size d_in = d_out
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class Cloner(builtins.object)
     |   Cloner class, useful to override classes with other cloning
     |  functions. The cloning function above just calls
     |  Cloner::clone_Index.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clone_Index(self, arg2)
     |
     |  clone_IndexIVF(self, arg2)
     |
     |  clone_VectorTransform(self, arg2)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Cloner(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Clustering(ClusteringParameters)
     |  Clustering(*args)
     |
     |   K-means clustering based on assignment - centroid update iterations
     |
     |  The clustering is based on an Index object that assigns training
     |  points to the centroids. Therefore, at each iteration the centroids
     |  are added to the index.
     |
     |  On output, the centroids table is set to the latest version
     |  of the centroids and they are also added to the index. If the
     |  centroids table it is not empty on input, it is also used for
     |  initialization.
     |
     |  Method resolution order:
     |      Clustering
     |      ClusteringParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  post_process_centroids(self)
     |      Post-process the centroids after each centroid update.
     |      includes optional L2 normalization and nearest integer rounding
     |
     |  train = replacement_train(self, x, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
     |      Perform clustering on a set of vectors. The index is used for assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |      index : faiss.Index
     |          Index used for assignment. The dimension of the index should be `self.d`.
     |      weights : array_like, optional
     |          Per training sample weight (size n) used when computing the weighted
     |          average to obtain the centroid (default is 1 for all training vectors).
     |
     |  train_c = train(self, n, x, index, x_weights=None)
     |       run k-means training
     |
     |      :type x: float
     |      :param x:          training vectors, size n * d
     |      :type index: :py:class:`Index`
     |      :param index:      index used for assignment
     |      :type x_weights: float, optional
     |      :param x_weights:  weight associated to each vector: NULL or size n
     |
     |  train_encoded = replacement_train_encoded(self, x, codec, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
     |      Perform clustering on a set of compressed vectors. The index is used for assignment.
     |      The decompression is performed on-the-fly.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, codec.code_size()). `dtype` must be `uint8`.
     |      codec : faiss.Index
     |          Index used to decode the vectors. Should have dimension `self.d`.
     |      index : faiss.Index
     |          Index used for assignment. The dimension of the index should be `self.d`.
     |      weights : array_like, optional
     |          Per training sample weight (size n) used when computing the weighted
     |          average to obtain the centroid (default is 1 for all training vectors).
     |
     |  train_encoded_c = train_encoded(self, nx, x_in, codec, index, weights=None)
     |       run with encoded vectors
     |
     |      in addition to train()'s parameters takes a codec as parameter
     |      to decode the input vectors.
     |
     |      :type codec: :py:class:`Index`
     |      :param codec:      codec used to decode the vectors (nullptr =
     |                            vectors are in fact floats)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Clustering(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centroids
     |       centroids (k * d)
     |      if centroids are set on input to train, they will be used as
     |      initialization
     |
     |  d
     |      dimension of the vectors
     |
     |  iteration_stats
     |      stats at every iteration of clustering
     |
     |  k
     |      nb of centroids
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ClusteringParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² initialization.
     |      Only used when init_method = AFK_MC2.
     |      Longer chains give better approximation but are slower.
     |
     |  check_input_data_for_NaNs
     |      whether to check for NaNs in an input data
     |
     |  decode_block_size
     |      when the training set is encoded, batch size of the codec decoder
     |
     |  early_stop_threshold
     |      Early stop threshold, the range is [0, 1].
     |      The value of 0 implies a default Faiss behavior,
     |      so the training process stops only if an error
     |      is unchanged from the previous iteration.
     |
     |  frozen_centroids
     |      Use the subset of centroids provided as input and do not change them
     |      during iterations
     |
     |  init_method
     |      Initialization method for centroids.
     |      RANDOM: uniform random sampling (default, current behavior)
     |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
     |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
     |
     |  int_centroids
     |      round centroids coordinates to integer after each iteration?
     |
     |  max_points_per_centroid
     |      to limit size of dataset, otherwise the training set is subsampled
     |
     |  min_points_per_centroid
     |      If fewer than this number of training vectors per centroid are provided,
     |      writes a warning. Note that fewer than 1 point per centroid raises an
     |      exception.
     |
     |  niter
     |      number of clustering iterations
     |
     |  nredo
     |      redo clustering this many times and keep the clusters with the best
     |      objective
     |
     |  seed
     |      seed for the random number generator.
     |      negative values lead to seeding an internal rng with
     |      std::high_resolution_clock.
     |
     |  spherical
     |      whether to normalize centroids after each iteration (useful for inner
     |      product clustering)
     |
     |  update_index
     |      re-train index after each iteration?
     |
     |  use_faster_subsampling
     |      Whether to use splitmix64-based random number generator for subsampling,
     |      which is faster, but may pick duplicate points.
     |
     |  verbose

    class Clustering1D(Clustering)
     |  Clustering1D(*args)
     |
     |   Exact 1D clustering algorithm
     |
     |  Since it does not use an index, it does not overload the train() function
     |
     |  Method resolution order:
     |      Clustering1D
     |      Clustering
     |      ClusteringParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  train_exact = replacement_train_exact(self, x) from faiss.class_wrappers.handle_Clustering1D.<locals>
     |      Perform clustering on a set of 1D vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, 1). `dtype` must be float32.
     |
     |  train_exact_c = train_exact(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Clustering1D(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Clustering:
     |
     |  post_process_centroids(self)
     |      Post-process the centroids after each centroid update.
     |      includes optional L2 normalization and nearest integer rounding
     |
     |  train = replacement_train(self, x, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
     |      Perform clustering on a set of vectors. The index is used for assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |      index : faiss.Index
     |          Index used for assignment. The dimension of the index should be `self.d`.
     |      weights : array_like, optional
     |          Per training sample weight (size n) used when computing the weighted
     |          average to obtain the centroid (default is 1 for all training vectors).
     |
     |  train_c = train(self, n, x, index, x_weights=None)
     |       run k-means training
     |
     |      :type x: float
     |      :param x:          training vectors, size n * d
     |      :type index: :py:class:`Index`
     |      :param index:      index used for assignment
     |      :type x_weights: float, optional
     |      :param x_weights:  weight associated to each vector: NULL or size n
     |
     |  train_encoded = replacement_train_encoded(self, x, codec, index, weights=None) from faiss.class_wrappers.handle_Clustering.<locals>
     |      Perform clustering on a set of compressed vectors. The index is used for assignment.
     |      The decompression is performed on-the-fly.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, codec.code_size()). `dtype` must be `uint8`.
     |      codec : faiss.Index
     |          Index used to decode the vectors. Should have dimension `self.d`.
     |      index : faiss.Index
     |          Index used for assignment. The dimension of the index should be `self.d`.
     |      weights : array_like, optional
     |          Per training sample weight (size n) used when computing the weighted
     |          average to obtain the centroid (default is 1 for all training vectors).
     |
     |  train_encoded_c = train_encoded(self, nx, x_in, codec, index, weights=None)
     |       run with encoded vectors
     |
     |      in addition to train()'s parameters takes a codec as parameter
     |      to decode the input vectors.
     |
     |      :type codec: :py:class:`Index`
     |      :param codec:      codec used to decode the vectors (nullptr =
     |                            vectors are in fact floats)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Clustering:
     |
     |  centroids
     |       centroids (k * d)
     |      if centroids are set on input to train, they will be used as
     |      initialization
     |
     |  d
     |      dimension of the vectors
     |
     |  iteration_stats
     |      stats at every iteration of clustering
     |
     |  k
     |      nb of centroids
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ClusteringParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² initialization.
     |      Only used when init_method = AFK_MC2.
     |      Longer chains give better approximation but are slower.
     |
     |  check_input_data_for_NaNs
     |      whether to check for NaNs in an input data
     |
     |  decode_block_size
     |      when the training set is encoded, batch size of the codec decoder
     |
     |  early_stop_threshold
     |      Early stop threshold, the range is [0, 1].
     |      The value of 0 implies a default Faiss behavior,
     |      so the training process stops only if an error
     |      is unchanged from the previous iteration.
     |
     |  frozen_centroids
     |      Use the subset of centroids provided as input and do not change them
     |      during iterations
     |
     |  init_method
     |      Initialization method for centroids.
     |      RANDOM: uniform random sampling (default, current behavior)
     |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
     |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
     |
     |  int_centroids
     |      round centroids coordinates to integer after each iteration?
     |
     |  max_points_per_centroid
     |      to limit size of dataset, otherwise the training set is subsampled
     |
     |  min_points_per_centroid
     |      If fewer than this number of training vectors per centroid are provided,
     |      writes a warning. Note that fewer than 1 point per centroid raises an
     |      exception.
     |
     |  niter
     |      number of clustering iterations
     |
     |  nredo
     |      redo clustering this many times and keep the clusters with the best
     |      objective
     |
     |  seed
     |      seed for the random number generator.
     |      negative values lead to seeding an internal rng with
     |      std::high_resolution_clock.
     |
     |  spherical
     |      whether to normalize centroids after each iteration (useful for inner
     |      product clustering)
     |
     |  update_index
     |      re-train index after each iteration?
     |
     |  use_faster_subsampling
     |      Whether to use splitmix64-based random number generator for subsampling,
     |      which is faster, but may pick duplicate points.
     |
     |  verbose

    class ClusteringInitialization(builtins.object)
     |  ClusteringInitialization(d, k)
     |
     |  Centroid initialization for k-means clustering.
     |
     |  This class provides different algorithms for selecting initial centroids
     |  before running k-means iterations. Good initialization can significantly
     |  improve clustering quality and convergence speed.
     |
     |  Example usage:
     |
     |  .. code-block:: c++
     |
     |          ClusteringInitialization init(128, 1000);  // d=128, k=1000
     |          init.method = ClusteringInitMethod::KMEANS_PLUS_PLUS;
     |          init.seed = 42;
     |
     |          std::vector<float> centroids(128 * 1000);
     |          init.init_centroids(n, x, centroids.data());
     |
     |  Methods defined here:
     |
     |  __init__(self, d, k)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  init_centroids(self, n, x, centroids, n_existing_centroids=0, existing_centroids=None)
     |      Initialize k centroids from n input vectors.
     |
     |      :type n: int
     |      :param n:          number of input vectors
     |      :type x: float
     |      :param x:          input vectors, size (n, d), row-major
     |      :type centroids: float
     |      :param centroids:  output centroids, size (k, d), row-major
     |      :type n_existing_centroids: int, optional
     |      :param n_existing_centroids:  number of pre-existing centroids to
     |          consider
     |                                       when computing distances (for k-means++ and
     |                                       AFK-MC²). These centroids are not modified.
     |      :type existing_centroids: float, optional
     |      :param existing_centroids:    pre-existing centroids, size
     |                                       (n_existing_centroids, d), row-major.
     |                                       New centroids will be selected to be far
     |                                       from these existing ones.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ClusteringInitialization(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² (only used when method = AFK_MC2).
     |      Longer chains give better approximation to k-means++ but are slower.
     |
     |  d
     |      vector dimension
     |
     |  k
     |      number of centroids to initialize
     |
     |  method
     |      Initialization method to use
     |
     |  seed
     |      Random seed.
     |
     |  thisown
     |      The membership flag

    class ClusteringIterationStats(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ClusteringIterationStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  imbalance_factor
     |      imbalance factor of iteration
     |
     |  nsplit
     |      number of cluster splits
     |
     |  obj
     |      objective values (sum of distances reported by index)
     |
     |  thisown
     |      The membership flag
     |
     |  time
     |      seconds for iteration
     |
     |  time_search
     |      seconds for just search

    class ClusteringIterationStatsVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ClusteringIterationStatsVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class ClusteringParameters(builtins.object)
     |   Class for the clustering parameters. Can be passed to the
     |  constructor of the Clustering object.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ClusteringParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² initialization.
     |      Only used when init_method = AFK_MC2.
     |      Longer chains give better approximation but are slower.
     |
     |  check_input_data_for_NaNs
     |      whether to check for NaNs in an input data
     |
     |  decode_block_size
     |      when the training set is encoded, batch size of the codec decoder
     |
     |  early_stop_threshold
     |      Early stop threshold, the range is [0, 1].
     |      The value of 0 implies a default Faiss behavior,
     |      so the training process stops only if an error
     |      is unchanged from the previous iteration.
     |
     |  frozen_centroids
     |      Use the subset of centroids provided as input and do not change them
     |      during iterations
     |
     |  init_method
     |      Initialization method for centroids.
     |      RANDOM: uniform random sampling (default, current behavior)
     |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
     |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
     |
     |  int_centroids
     |      round centroids coordinates to integer after each iteration?
     |
     |  max_points_per_centroid
     |      to limit size of dataset, otherwise the training set is subsampled
     |
     |  min_points_per_centroid
     |      If fewer than this number of training vectors per centroid are provided,
     |      writes a warning. Note that fewer than 1 point per centroid raises an
     |      exception.
     |
     |  niter
     |      number of clustering iterations
     |
     |  nredo
     |      redo clustering this many times and keep the clusters with the best
     |      objective
     |
     |  seed
     |      seed for the random number generator.
     |      negative values lead to seeding an internal rng with
     |      std::high_resolution_clock.
     |
     |  spherical
     |      whether to normalize centroids after each iteration (useful for inner
     |      product clustering)
     |
     |  thisown
     |      The membership flag
     |
     |  update_index
     |      re-train index after each iteration?
     |
     |  use_faster_subsampling
     |      Whether to use splitmix64-based random number generator for subsampling,
     |      which is faster, but may pick duplicate points.
     |
     |  verbose

    class CodePacker(builtins.object)
     |  CodePacker(*args, **kwargs)
     |
     |  Packing consists in combining a fixed number of codes of constant size
     |  (code_size) into a block of data where they may (or may not) be interleaved
     |  for efficient consumption by distance computation kernels. This exists for
     |  the "fast_scan" indexes on CPU and for some GPU kernels.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clone(self)
     |
     |  pack_1 = replacement_pack_1(self, x, offset, block) from faiss.class_wrappers.handle_CodePacker.<locals>
     |
     |  pack_1_c = pack_1(self, flat_code, offset, block)
     |
     |  pack_all(self, flat_codes, block)
     |
     |  unpack_1 = replacement_unpack_1(self, block, offset) from faiss.class_wrappers.handle_CodePacker.<locals>
     |
     |  unpack_1_c = unpack_1(self, block, offset, flat_code)
     |
     |  unpack_all(self, block, flat_codes)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CodePacker(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  block_size
     |
     |  code_size
     |
     |  nvec
     |
     |  thisown
     |      The membership flag

    class CodePackerFlat(CodePacker)
     |  CodePackerFlat(code_size)
     |
     |  Trivial code packer where codes are stored one by one
     |
     |  Method resolution order:
     |      CodePackerFlat
     |      CodePacker
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, code_size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clone(self)
     |
     |  pack_1 = replacement_pack_1(self, x, offset, block) from faiss.class_wrappers.handle_CodePacker.<locals>
     |
     |  pack_1_c = pack_1(self, flat_code, offset, block)
     |
     |  pack_all(self, flat_codes, block)
     |
     |  unpack_1 = replacement_unpack_1(self, block, offset) from faiss.class_wrappers.handle_CodePacker.<locals>
     |
     |  unpack_1_c = unpack_1(self, block, offset, flat_code)
     |
     |  unpack_all(self, block, flat_codes)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CodePackerFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CodePacker:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  block_size
     |
     |  code_size
     |
     |  nvec

    class CodeSet(builtins.object)
     |  CodeSet(d_in)
     |
     |  Methods defined here:
     |
     |  __init__(self, d_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  insert = replacement_insert(self, codes, inserted=None) from faiss.class_wrappers.handle_CodeSet.<locals>
     |
     |  insert_c = insert(self, n, codes, inserted)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CodeSet(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |
     |  s
     |
     |  thisown
     |      The membership flag

    class CombinerRangeKNNfloat(builtins.object)
     |  CombinerRangeKNNfloat(nq_in, k_in, r2_in, keep_max_in)
     |
     |   This class is used to combine range and knn search results
     |  in contrib.exhaustive_search.range_search_gpu
     |
     |  Methods defined here:
     |
     |  __init__(self, nq_in, k_in, r2_in, keep_max_in)
     |      whether to keep max values instead of min.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_sizes(self, L_res)
     |      size nq + 1
     |
     |  write_result(self, D_res, I_res)
     |      Phase 2: caller allocates D_res and I_res (size L_res[nq])
     |      Phase 3: fill in D_res and I_res
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CombinerRangeKNNfloat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  D
     |      size nq * k
     |
     |  D_remain
     |      size nrange + 1
     |
     |  I
     |      Knn search results
     |
     |  I_remain
     |      size lim_remain[nrange]
     |
     |  L_res
     |      size lim_remain[nrange]
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  k
     |      nb of queries
     |
     |  keep_max
     |      range search radius
     |
     |  lim_remain
     |      mask for where knn results are valid, size nq
     |
     |  mask
     |      size nq * k
     |      optional: range search results (ignored if mask is NULL)
     |
     |  nq
     |
     |  r2
     |      number of neighbors for the knn search part
     |
     |  thisown
     |      The membership flag

    class CombinerRangeKNNint16(builtins.object)
     |  CombinerRangeKNNint16(nq_in, k_in, r2_in, keep_max_in)
     |
     |   This class is used to combine range and knn search results
     |  in contrib.exhaustive_search.range_search_gpu
     |
     |  Methods defined here:
     |
     |  __init__(self, nq_in, k_in, r2_in, keep_max_in)
     |      whether to keep max values instead of min.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_sizes(self, L_res)
     |      size nq + 1
     |
     |  write_result(self, D_res, I_res)
     |      Phase 2: caller allocates D_res and I_res (size L_res[nq])
     |      Phase 3: fill in D_res and I_res
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_CombinerRangeKNNint16(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  D
     |      size nq * k
     |
     |  D_remain
     |      size nrange + 1
     |
     |  I
     |      Knn search results
     |
     |  I_remain
     |      size lim_remain[nrange]
     |
     |  L_res
     |      size lim_remain[nrange]
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  k
     |      nb of queries
     |
     |  keep_max
     |      range search radius
     |
     |  lim_remain
     |      mask for where knn results are valid, size nq
     |
     |  mask
     |      size nq * k
     |      optional: range search results (ignored if mask is NULL)
     |
     |  nq
     |
     |  r2
     |      number of neighbors for the knn search part
     |
     |  thisown
     |      The membership flag

    class ComputeCodesAddCentroidsLUT0MemoryPool(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ComputeCodesAddCentroidsLUT0MemoryPool(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  codes
     |
     |  distances
     |
     |  norms
     |
     |  refine_beam_pool
     |
     |  residuals
     |
     |  thisown
     |      The membership flag

    class ComputeCodesAddCentroidsLUT1MemoryPool(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ComputeCodesAddCentroidsLUT1MemoryPool(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  codes
     |
     |  distances
     |
     |  query_cp
     |
     |  query_norms
     |
     |  refine_beam_lut_pool
     |
     |  residuals
     |
     |  thisown
     |      The membership flag

    class DefaultShardingFunction(ShardingFunction)
     |  Method resolution order:
     |      DefaultShardingFunction
     |      ShardingFunction
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, i, shard_count)
     |      Call self as a function.
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_DefaultShardingFunction(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ShardingFunction:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class DirectMap(builtins.object)
     |  Direct map: a way to map back from ids to inverted lists
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_single_id(self, id, list_no, offset)
     |      non thread-safe version
     |
     |  check_can_add(self, ids)
     |      update the direct_map
     |
     |       throw if Array and ids is not NULL
     |
     |  clear(self)
     |      remove all entries
     |
     |  get(self, id)
     |      get an entry
     |
     |  no(self)
     |      for quick checks
     |
     |  remove_ids(self, sel, invlists)
     |      operations on inverted lists that require translation with a DirectMap
     |
     |       remove ids from the InvertedLists, possibly using the direct map
     |
     |  set_type(self, new_type, invlists, ntotal)
     |      set type and initialize
     |
     |  update_codes(self, invlists, n, ids, list_nos, codes)
     |      update entries, using the direct map
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_DirectMap(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  array
     |      map for direct access to the elements. Map ids to LO-encoded entries.
     |
     |  hashtable
     |
     |  thisown
     |      The membership flag
     |
     |  type
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  Array = 1
     |
     |  DMT_count = 3
     |
     |  Hashtable = 2
     |
     |  NoMap = 0

    class DirectMapAdd(builtins.object)
     |  DirectMapAdd(direct_map, n, xids)
     |
     |  Thread-safe way of updating the direct_map
     |
     |  Methods defined here:
     |
     |  __init__(self, direct_map, n, xids)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, i, list_no, offset)
     |      add vector i (with id xids[i]) at list_no and offset
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_DirectMapAdd(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  all_ofs
     |
     |  direct_map
     |
     |  n
     |
     |  ntotal
     |
     |  thisown
     |      The membership flag
     |
     |  type
     |
     |  xids

    class DistanceComputer(builtins.object)
     |  DistanceComputer(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __call__(self, i)
     |      compute distance of vector i to current query
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
     |      compute distances of current query to 4 stored vectors.
     |      certain DistanceComputer implementations may benefit
     |      heavily from this.
     |
     |  set_query(self, x)
     |      called before computing distances. Pointer x should remain valid
     |      while operator () is called
     |
     |  symmetric_dis(self, i, j)
     |      compute distance between two stored vectors
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_DistanceComputer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Embedding(builtins.object)
     |  Embedding(*args)
     |
     |  minimal translation of nn.Embedding
     |
     |  Methods defined here:
     |
     |  __call__(self, arg2)
     |      Call self as a function.
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Embedding.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  data(self, *args)
     |
     |  from_array(self, array) from faiss.class_wrappers.handle_Embedding.<locals>
     |      copy weights from numpy array
     |
     |  from_torch(self, emb) from faiss.class_wrappers.handle_Embedding.<locals>
     |      copy weights from torch.Embedding
     |
     |  original_init = __init__(self, num_embeddings, embedding_dim)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Embedding(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  embedding_dim
     |
     |  num_embeddings
     |
     |  thisown
     |      The membership flag
     |
     |  weight

    class EnumeratedVectors(builtins.object)
     |  EnumeratedVectors(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, code, c)
     |      decode it
     |
     |  decode_multi(self, nc, codes, c)
     |
     |  encode(self, x)
     |      encode a vector from a collection
     |
     |  encode_multi(self, nc, c, codes)
     |
     |  find_nn(self, n, codes, nq, xq, idx, dis)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_EnumeratedVectors(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dim
     |
     |  nv
     |      size of the collection
     |
     |  thisown
     |      The membership flag

    class ExtraBitsFactors(builtins.object)
     |   Additional factors for multi-bit RaBitQ (nb_bits > 1).
     |  Used to store normalization and scaling factors for the refinement bits
     |  that encode additional precision beyond the sign bit.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ExtraBitsFactors(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  f_add_ex
     |
     |  f_rescale_ex
     |
     |  thisown
     |      The membership flag

    class FFN(builtins.object)
     |  FFN(d, h)
     |
     |  Feed forward layer that expands to a hidden dimension, applies a ReLU non
     |  linearity and maps back to the original dimension
     |
     |  Methods defined here:
     |
     |  __call__(self, x)
     |      Call self as a function.
     |
     |  __init__(self, d, h)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_FFN(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  linear1
     |
     |  linear2
     |
     |  thisown
     |      The membership flag

    class FastScanDistancePostProcessing(builtins.object)
     |  Simple context object that holds processors for FastScan operations.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Default constructor - no processing
     |
     |  __repr__ = _swig_repr(self)
     |
     |  has_norm_scaling(self)
     |      Check if norm scaling is enabled
     |
     |  has_query_processing(self)
     |      Check if query factors processing is enabled
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_FastScanDistancePostProcessing(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  centered
     |      RaBitQ centered scalar quantizer override.
     |      Only used when qb > 0 (i.e., when params are overridden).
     |
     |  nprobe
     |      The nprobe value used when allocating query_factors storage.
     |      This is needed because the allocation size (n * nprobe) may use a
     |      different nprobe than index->nprobe if search params override it.
     |      Set to 0 to use index->nprobe as fallback.
     |
     |  pq2x4_scale
     |      Norm scaling processor for Additive Quantizers.
     |      The scale is encoded in a 2x4 bit PQ table, then scaled by this int.
     |      Set to 0 if unused.
     |
     |  qb
     |      RaBitQ query quantization bits override.
     |      Set to 0 to use the index default (index->qb).
     |
     |  query_factors
     |      Query factors data pointer for RaBitQ (nullptr if not needed)
     |      This pointer should point to the beginning of the relevant
     |      QueryFactorsData subset for this context.
     |
     |  thisown
     |      The membership flag

    class FastScanStats(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_FastScanStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  t0
     |
     |  t1
     |
     |  t2
     |
     |  t3
     |
     |  thisown
     |      The membership flag

    class FileIOReader(IOReader)
     |  FileIOReader(*args)
     |
     |  Method resolution order:
     |      FileIOReader
     |      IOReader
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  filedescriptor(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_FileIOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  f
     |
     |  need_close
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOReader:
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOReader:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class FileIOWriter(IOWriter)
     |  FileIOWriter(*args)
     |
     |  Method resolution order:
     |      FileIOWriter
     |      IOWriter
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  filedescriptor(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_FileIOWriter(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  f
     |
     |  need_close
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOWriter:
     |
     |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOWriter:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class FlatCodesDistanceComputer(DistanceComputer)
     |  FlatCodesDistanceComputer(*args, **kwargs)
     |
     |  Method resolution order:
     |      FlatCodesDistanceComputer
     |      DistanceComputer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, i)
     |      compute distance of vector i to current query
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  distance_to_code(self, code)
     |      compute distance of current query to an encoded vector
     |
     |  partial_dot_product(self, arg2, arg3, arg4)
     |      Computes a partial dot product over a slice of the query vector.
     |      The slice is defined by the following parameters:
     |        — `offset`: the starting index of the first component to include
     |        — `num_components`: the number of consecutive components to include
     |
     |      Components refer to raw dimensions of the flat (uncompressed) query
     |      vector.
     |
     |      By default, this method throws an error, as it is only implemented
     |      in specific subclasses such as `FlatL2Dis`. Other flat distance
     |      computers may override this when partial dot product support is needed.
     |
     |      Over time, this method might be changed to a pure virtual function (`=
     |      0`) to enforce implementation in subclasses that require this
     |      functionality.
     |
     |      This method is not part of the generic `DistanceComputer` interface
     |      because for compressed representations (e.g., product quantization),
     |      calling `partial_dot_product` repeatedly is often less efficient than
     |      computing the full distance at once.
     |
     |      Supporting efficient partial scans generally requires a different memory
     |      layout, such as interleaved blocks that keep SIMD lanes full. This is a
     |      non-trivial change and not supported in the current flat layout.
     |
     |      For more details on partial (or chunked) dot product computations and
     |      the performance trade-offs involved, refer to the Panorama paper:
     |      https://arxiv.org/pdf/2510.00566
     |
     |  partial_dot_product_batch_4(self, idx0, idx1, idx2, idx3, dp0, dp1, dp2, dp3, offset, num_components)
     |      Compute partial dot products of current query to 4 stored vectors.
     |      See `partial_dot_product` for more details.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_FlatCodesDistanceComputer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  code_size
     |
     |  codes
     |
     |  q
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from DistanceComputer:
     |
     |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
     |      compute distances of current query to 4 stored vectors.
     |      certain DistanceComputer implementations may benefit
     |      heavily from this.
     |
     |  set_query(self, x)
     |      called before computing distances. Pointer x should remain valid
     |      while operator () is called
     |
     |  symmetric_dis(self, i, j)
     |      compute distance between two stored vectors
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from DistanceComputer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Float32Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Float32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Float32VectorVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Float32VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Float64Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Float64Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class HNSW(builtins.object)
     |  HNSW(M=32)
     |
     |  Methods defined here:
     |
     |  __init__(self, M=32)
     |      only mandatory parameter: nb of neighbors
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_links_starting_from(self, ptdis, pt_id, nearest, d_nearest, level, locks, vt, keep_max_size_level0=False)
     |
     |  add_with_locks(self, ptdis, pt_level, pt_id, locks, vt, keep_max_size_level0=False)
     |       add point pt_id on all levels <= pt_level and build the link
     |      structure for them.
     |
     |  clear_neighbor_tables(self, level)
     |
     |  cum_nb_neighbors(self, layer_no)
     |      cumulative nb up to (and excluding) this level
     |
     |  fill_with_random_links(self, n)
     |      add n random levels to table (for debugging...)
     |
     |  nb_neighbors(self, layer_no)
     |      nb of neighbors for this level
     |
     |  neighbor_range(self, no, layer_no, begin, end)
     |      range of entries in the neighbors table of vertex no at layer_no
     |
     |  permute_entries(self, map)
     |
     |  prepare_level_tab(self, n, preset_levels=False)
     |
     |  print_neighbor_stats(self, level)
     |
     |  random_level(self)
     |      pick a random level for a new point
     |
     |  reset(self)
     |
     |  search(self, qdis, index, res, vt, params=None)
     |      Search interface for 1 point, single thread
     |
     |      NOTE: We pass a reference to the index itself to allow for additional
     |      state information to be passed (used for Panorama progressive pruning).
     |      The alternative would be to override both HNSW::search and
     |      HNSWIndex::search, which would be a nuisance of code duplication.
     |
     |  search_level_0(self, qdis, res, nprobe, nearest_i, nearest_d, search_type, search_stats, vt, params=None)
     |      search only in level 0 from a given vertex
     |
     |  set_default_probas(self, M, levelMult)
     |      initialize the assign_probas and cum_nneighbor_per_level to
     |      have 2*M links on level 0 and M links on levels > 0
     |
     |  set_nb_neighbors(self, level_no, n)
     |      set nb of neighbors for this level (before adding anything)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_HNSW(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  assign_probas
     |      assignment probability to each layer (sum=1)
     |
     |  check_relative_distance
     |      during search: do we check whether the next best distance is good
     |      enough?
     |
     |  cum_nneighbor_per_level
     |      number of neighbors stored per layer (cumulative), should not
     |      be changed after first add
     |
     |  efConstruction
     |      expansion factor at construction time
     |
     |  efSearch
     |      expansion factor at search time
     |
     |  entry_point
     |      entry point in the search structure (one of the points with maximum
     |      level
     |
     |  is_panorama
     |      use Panorama progressive pruning in search
     |
     |  is_similarity
     |      distance comparison semantics: when true, distances are treated as
     |      similarity scores (larger is better). Default false matches the
     |      historical L2/Hamming behavior (smaller is better).
     |      Not serialized: must be re-set by the owning Index after loading.
     |
     |  levels
     |      level of each vector (base level = 1), size = ntotal
     |
     |  max_level
     |      maximum level
     |
     |  neighbors
     |      neighbors[offsets[i]:offsets[i+1]] is the list of neighbors of vector i
     |      for all levels. this is where all storage goes.
     |
     |  offsets
     |      offsets[i] is the offset in the neighbors array where vector i is stored
     |      size ntotal + 1
     |
     |  prune_headroom
     |      when pruning, leave room for more neighbors to avoid O(n^2)
     |      costs and lock contention on frequently-pruned nodes.
     |
     |  rng
     |
     |  search_bounded_queue
     |      use bounded queue during exploration
     |
     |  thisown
     |      The membership flag
     |
     |  use_visited_hashset

    class HNSWStats(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  combine(self, other)
     |
     |  reset(self)
     |      number of hops aka number of edges traversed
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_HNSWStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n1
     |
     |  n2
     |      number of vectors searched
     |
     |  ndis
     |      number of queries for which the candidate list is exhausted
     |
     |  nhops
     |      number of distances computed
     |
     |  thisown
     |      The membership flag

    class HStackInvertedLists(ReadOnlyInvertedLists)
     |  HStackInvertedLists(n_il, ils)
     |
     |  Horizontal stack of inverted lists
     |
     |  Method resolution order:
     |      HStackInvertedLists
     |      ReadOnlyInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, n_il, ils)
     |      build InvertedLists by concatenating nil of them
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_HStackInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  ils
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ReadOnlyInvertedLists:
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class HadamardRotation(VectorTransform)
     |  HadamardRotation(*args)
     |
     |   Three rounds of random sign-flip + Fast Walsh-Hadamard Transform.
     |  Produces a pseudo-random rotation in O(d log d) time.
     |  d_out is the smallest power of 2 >= d_in (zero-padded as needed).
     |
     |  Method resolution order:
     |      HadamardRotation
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |       apply the transformation and return the result in a provided matrix
     |      :type n: int
     |      :param n: number of vectors to transform
     |      :type x: float
     |      :param x: input vectors, size n * d_in
     |      :type xt: float
     |      :param xt: output vectors, size n * d_out
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  init(self, seed_in)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x) from VectorTransform
     |      reverse transformation. May not be implemented or may return
     |      approximate result
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_HadamardRotation(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  seed
     |
     |  signs1
     |      Sign-flip vectors, each of size d_out, generated from seed.
     |
     |  signs2
     |
     |  signs3
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class IDSelector(builtins.object)
     |  IDSelector(*args, **kwargs)
     |
     |  Encapsulates a set of ids to handle.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class IDSelectorAll(IDSelector)
     |  selects all entries (useful for benchmarking)
     |
     |  Method resolution order:
     |      IDSelectorAll
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, arg2)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorAll(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorAnd(IDSelector)
     |  IDSelectorAnd(*args)
     |
     |  does an AND operation on the two given IDSelector's is_membership
     |  results.
     |
     |  Method resolution order:
     |      IDSelectorAnd
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorAnd(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lhs
     |
     |  rhs
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorArray(IDSelector)
     |  IDSelectorArray(*args)
     |
     |   Simple array of elements
     |
     |  is_member calls are very inefficient, but some operations can use the ids
     |  directly.
     |
     |  Method resolution order:
     |      IDSelectorArray
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_IDSelectorSubset.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  original_init = __init__(self, n, ids)
     |       Construct with an array of ids to process
     |
     |      :type n: int
     |      :param n: number of ids to store
     |      :type ids: int
     |      :param ids: elements to store. The pointer should remain valid during
     |                     IDSelectorArray's lifetime
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorArray(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  ids
     |
     |  n
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorBatch(IDSelector)
     |  IDSelectorBatch(*args)
     |
     |   Ids from a set.
     |
     |  Repetitions of ids in the indices set passed to the constructor does not hurt
     |  performance.
     |
     |  The hash function used for the bloom filter and GCC's implementation of
     |  unordered_set are just the least significant bits of the id. This works fine
     |  for random ids or ids in sequences but will produce many hash collisions if
     |  lsb's are always the same
     |
     |  Method resolution order:
     |      IDSelectorBatch
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_IDSelectorSubset.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  original_init = __init__(self, n, indices)
     |       Construct with an array of ids to process
     |
     |      :type n: int
     |      :param n: number of ids to store
     |      :param ids: elements to store. The pointer can be released after
     |                     construction
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorBatch(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  mask
     |
     |  nbits
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorBitmap(IDSelector)
     |  IDSelectorBitmap(*args)
     |
     |  One bit per element. Constructed with a bitmap, size ceil(n / 8).
     |
     |  Method resolution order:
     |      IDSelectorBitmap
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_IDSelectorSubset.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  original_init = __init__(self, n, bitmap)
     |       Construct with a binary mask
     |
     |      :type n: int
     |      :param n: size of the bitmap array
     |      :type bitmap: uint8_t
     |      :param bitmap: id will be selected iff id / 8 < n and bit number
     |                        (i%8) of bitmap[floor(i / 8)] is 1.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorBitmap(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  bitmap
     |
     |  n
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorNot(IDSelector)
     |  IDSelectorNot(*args)
     |
     |  reverts the membership test of another selector
     |
     |  Method resolution order:
     |      IDSelectorNot
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorNot(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  sel
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorOr(IDSelector)
     |  IDSelectorOr(*args)
     |
     |  does an OR operation on the two given IDSelector's is_membership
     |  results.
     |
     |  Method resolution order:
     |      IDSelectorOr
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorOr(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lhs
     |
     |  rhs
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorRange(IDSelector)
     |  IDSelectorRange(imin, imax, assume_sorted=False)
     |
     |  ids between [imin, imax)
     |
     |  Method resolution order:
     |      IDSelectorRange
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, imin, imax, assume_sorted=False)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  find_sorted_ids_bounds(self, list_size, ids, jmin, jmax)
     |      for sorted ids, find the range of list indices where the valid ids are
     |      stored
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorRange(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  assume_sorted
     |      Assume that the ids to handle are sorted. In some cases this can speed
     |      up processing
     |
     |  imax
     |
     |  imin
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorTranslated(IDSelector)
     |  IDSelectorTranslated(*args)
     |
     |  Method resolution order:
     |      IDSelectorTranslated
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorTranslated(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  id_map
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  sel
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IDSelectorXOr(IDSelector)
     |  IDSelectorXOr(*args)
     |
     |  does an XOR operation on the two given IDSelector's is_membership
     |  results.
     |
     |  Method resolution order:
     |      IDSelectorXOr
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IDSelectorXOr(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lhs
     |
     |  rhs
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class IOReader(builtins.object)
     |  IOReader(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  filedescriptor(self)
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name
     |
     |  thisown
     |      The membership flag

    class IOWriter(builtins.object)
     |  IOWriter(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  filedescriptor(self)
     |
     |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IOWriter(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name
     |
     |  thisown
     |      The membership flag

    class ITQMatrix(LinearTransform)
     |  ITQMatrix(d=0)
     |
     |   ITQ implementation from
     |
     |      Iterative quantization: A procrustean approach to learning binary codes
     |      for large-scale image retrieval,
     |
     |  Yunchao Gong, Svetlana Lazebnik, Albert Gordo, Florent Perronnin,
     |  PAMI'12.
     |
     |  Method resolution order:
     |      ITQMatrix
     |      LinearTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, d=0)
     |      both d_in > d_out and d_out < d_in are supported
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x) from LinearTransform
     |      works only if is_orthonormal
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ITQMatrix(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  init_rotation
     |
     |  max_iter
     |
     |  seed
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from LinearTransform:
     |
     |  apply_noalloc(self, n, x, xt)
     |      same as apply, but result is pre-allocated
     |
     |  check_identical(self, other)
     |
     |  print_if_verbose(self, name, mat, n, d)
     |
     |  set_is_orthonormal(self)
     |      compute A^T * A to set the is_orthonormal flag
     |
     |  transform_transpose(self, n, y, x)
     |      compute x = A^T * (x - b)
     |      is reverse transform if A has orthonormal lines
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from LinearTransform:
     |
     |  A
     |      Transformation matrix, size d_out * d_in
     |
     |  b
     |      bias vector, size d_out
     |
     |  have_bias
     |
     |  is_orthonormal
     |      whether to use the bias term
     |       check if matrix A is orthonormal (enables reverse_transform)
     |
     |  verbose
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class ITQTransform(VectorTransform)
     |  ITQTransform(din=0, dout=0, do_pca_in=False)
     |
     |  The full ITQ transform, including normalizations and PCA transformation
     |
     |  Method resolution order:
     |      ITQTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, din=0, dout=0, do_pca_in=False)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |       apply the transformation and return the result in a provided matrix
     |      :type n: int
     |      :param n: number of vectors to transform
     |      :type x: float
     |      :param x: input vectors, size n * d_in
     |      :type xt: float
     |      :param xt: output vectors, size n * d_out
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x) from VectorTransform
     |      reverse transformation. May not be implemented or may return
     |      approximate result
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ITQTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  do_pca
     |
     |  itq
     |
     |  max_train_per_dim
     |      max training points per dimension
     |
     |  mean
     |
     |  pca_then_itq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class IVFFastScanStats(builtins.object)
     |  Methods defined here:
     |
     |  Mcy_at(self, i)
     |
     |  Mcy_reservoir_at(self, i)
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IVFFastScanStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  reservoir_times
     |
     |  t_aq_encode
     |
     |  t_aq_norm_encode
     |
     |  t_compute_distance_tables
     |
     |  t_copy_pack
     |
     |  t_round
     |
     |  t_scan
     |
     |  t_to_flat
     |
     |  thisown
     |      The membership flag
     |
     |  times

    class IVFPQSearchParameters(SearchParametersIVF)
     |  IVFPQSearchParameters(**args)
     |
     |  Method resolution order:
     |      IVFPQSearchParameters
     |      SearchParametersIVF
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IVFPQSearchParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  polysemous_ht
     |      Hamming thresh for polysemous filtering
     |
     |  scan_table_threshold
     |      use table computation or on-the-fly?
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParametersIVF:
     |
     |  ensure_topk_full
     |      For k-NN search, make small early-stop budgets less aggressive:
     |      max_codes is treated as at least k post-IDSelector scans. Supported
     |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
     |      implementations 10 and 11.
     |
     |  inverted_list_context
     |      context object to pass to InvertedLists
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  max_empty_result_buckets
     |      Range-search only: stop after this many consecutive probed lists add
     |      no in-radius results. 0 disables the heuristic. This trades recall
     |      for less work. Supported in parallel_mode 0; FastScan range search
     |      uses implementation 10 for this option.
     |
     |  max_lists_num
     |      FastScan k-NN only: maximum number of inverted lists to visit.
     |      0 means unlimited, i.e. bounded only by nprobe. When set together
     |      with max_codes, either budget may stop the scan. With
     |      ensure_topk_full, this limit is treated as at least k lists.
     |
     |  nprobe
     |      number of probes at query time
     |
     |  quantizer_params
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class IVFRaBitQSearchParameters(SearchParametersIVF)
     |  IVFRaBitQSearchParameters(**args)
     |
     |  Method resolution order:
     |      IVFRaBitQSearchParameters
     |      SearchParametersIVF
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IVFRaBitQSearchParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centered
     |
     |  qb
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParametersIVF:
     |
     |  ensure_topk_full
     |      For k-NN search, make small early-stop budgets less aggressive:
     |      max_codes is treated as at least k post-IDSelector scans. Supported
     |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
     |      implementations 10 and 11.
     |
     |  inverted_list_context
     |      context object to pass to InvertedLists
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  max_empty_result_buckets
     |      Range-search only: stop after this many consecutive probed lists add
     |      no in-radius results. 0 disables the heuristic. This trades recall
     |      for less work. Supported in parallel_mode 0; FastScan range search
     |      uses implementation 10 for this option.
     |
     |  max_lists_num
     |      FastScan k-NN only: maximum number of inverted lists to visit.
     |      0 means unlimited, i.e. bounded only by nprobe. When set together
     |      with max_codes, either budget may stop the scan. With
     |      ensure_topk_full, this limit is treated as at least k lists.
     |
     |  nprobe
     |      number of probes at query time
     |
     |  quantizer_params
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class IVFSQTurboQSearchParameters(SearchParametersIVF)
     |  IVFSQTurboQSearchParameters(**args)
     |
     |   An IVF implementation where the components of the residuals are
     |  encoded with a scalar quantizer. All distance computations
     |  are asymmetric, so the encoded vectors are decoded and approximate
     |  distances are computed.
     |
     |   Search parameters for TurboQuant full types (QT_*_tq).
     |
     |  Method resolution order:
     |      IVFSQTurboQSearchParameters
     |      SearchParametersIVF
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IVFSQTurboQSearchParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  int_qjl
     |      Also use integer popcount for QJL stage (requires qb > 0).
     |
     |  qb
     |      Query quantization bits for integer MSE pre-screening.
     |      0 = float path (default), 1-8 = integer popcount path.
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParametersIVF:
     |
     |  ensure_topk_full
     |      For k-NN search, make small early-stop budgets less aggressive:
     |      max_codes is treated as at least k post-IDSelector scans. Supported
     |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
     |      implementations 10 and 11.
     |
     |  inverted_list_context
     |      context object to pass to InvertedLists
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  max_empty_result_buckets
     |      Range-search only: stop after this many consecutive probed lists add
     |      no in-radius results. 0 disables the heuristic. This trades recall
     |      for less work. Supported in parallel_mode 0; FastScan range search
     |      uses implementation 10 for this option.
     |
     |  max_lists_num
     |      FastScan k-NN only: maximum number of inverted lists to visit.
     |      0 means unlimited, i.e. bounded only by nprobe. When set together
     |      with max_codes, either budget may stop the scan. With
     |      ensure_topk_full, this limit is treated as at least k lists.
     |
     |  nprobe
     |      number of probes at query time
     |
     |  quantizer_params
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class IcmEncoder(builtins.object)
     |  IcmEncoder(lsq)
     |
     |  Methods defined here:
     |
     |  __init__(self, lsq)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  encode(self, codes, x, gen, n, ils_iters)
     |       Encode vectors given codebooks
     |
     |      :type codes: int
     |      :param codes:     output codes, size n * M
     |      :type x: float
     |      :param x:         vectors to encode, size n * d
     |      :type gen: std::mt19937
     |      :param gen:       random generator
     |      :type n: int
     |      :param n:         number of vectors
     |      :type ils_iters: int
     |      :param ils_iters: number of iterations of iterative local search
     |
     |  set_binary_term(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IcmEncoder(...)
     |      compute binary terms
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  binaries
     |
     |  lsq
     |
     |  thisown
     |      The membership flag
     |
     |  verbose

    class IcmEncoderFactory(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get(self, lsq)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IcmEncoderFactory(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Index(builtins.object)
     |  Index(*args, **kwargs)
     |
     |   Abstract structure for an index, supports adding vectors and searching
     |  them.
     |
     |  All vectors provided at add or search time are 32-bit float arrays,
     |  although the internal representation may vary.
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |       Add n vectors of dimension d to the index.
     |
     |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
     |      This function slices the input vectors in chunks smaller than
     |      blocksize_add and calls add_core.
     |      :type n: int
     |      :param n:      number of vectors
     |      :type x: float
     |      :param x:      input matrix, size n * d
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return at most k vectors. If there are not enough results for a
     |      query, the result array is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Index(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  thisown
     |      The membership flag
     |
     |  verbose
     |      verbosity level

    class Index2Layer(IndexFlatCodes)
     |  Index2Layer(*args)
     |
     |   Same as an IndexIVFPQ without the inverted lists: codes are stored
     |  sequentially
     |
     |  The class is mainly intended to store encoded vectors that can be
     |  accessed randomly, the search function is not implemented.
     |
     |  Method resolution order:
     |      Index2Layer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatCodes
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatCodes
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      not implemented
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  transfer_to_IVFPQ(self, other)
     |      transfer the flat codes to an IVFPQ index
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Index2Layer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  code_size_1
     |      size of the code for the first level (ceil(log8(q1.nlist)))
     |
     |  code_size_2
     |      size of the code for the second level
     |
     |  pq
     |      second level quantizer is always a PQ
     |
     |  q1
     |      first level quantizer
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexAdditiveQuantizer(IndexFlatCodes)
     |  IndexAdditiveQuantizer(*args)
     |
     |  Abstract class for additive quantizers. The search functions are in common.
     |
     |  Method resolution order:
     |      IndexAdditiveQuantizer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatCodes
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatCodes
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexAdditiveQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  aq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexAdditiveQuantizerFastScan(IndexFastScan)
     |  IndexAdditiveQuantizerFastScan(*args)
     |
     |   Fast scan version of IndexAQ. Works for 4-bit AQ for now.
     |
     |  The codes are not stored sequentially but grouped in blocks of size bbs.
     |  This makes it possible to compute distances quickly with SIMD instructions.
     |
     |  Implementations:
     |  12: blocked loop with internal loop on Q with qbs
     |  13: same with reservoir accumulator to store results
     |  14: no qbs with heap accumulator
     |  15: no qbs with reservoir accumulator
     |
     |  Method resolution order:
     |      IndexAdditiveQuantizerFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |      build from an existing IndexAQ
     |
     |      |
     |
     |      *Overload 2:*
     |      build from an existing IndexAQ
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFastScan
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, *args)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFastScan
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFastScan
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors.
     |
     |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
     |             contiguous. But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from IndexFastScan
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexAdditiveQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinary(builtins.object)
     |  IndexBinary(*args, **kwargs)
     |
     |   Abstract structure for a binary index.
     |
     |  Supports adding vertices and searching them.
     |
     |  All queries are symmetric because there is no distinction between codes and
     |  vectors.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |       Add n vectors of dimension d to the index.
     |
     |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
     |      :type x: uint8_t
     |      :param x:      input matrix, size n * d / 8
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return at most k vectors. If there are not enough results for a
     |      query, the result array is padded with -1s.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type distances: int
     |      :param distances:   output pairwise distances, size n*k
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: uint8_t
     |      :param x:      training vectors, size n * d / 8
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinary(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  thisown
     |      The membership flag
     |
     |  verbose
     |      verbosity level

    class IndexBinaryFlat(IndexBinary)
     |  IndexBinaryFlat(*args)
     |
     |  Index that stores the full vectors and performs exhaustive search.
     |
     |  Method resolution order:
     |      IndexBinaryFlat
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       Remove some ids. Note that because of the indexing structure,
     |      the semantics of this operation are different from the usual ones:
     |      the new ids are shifted.
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  approx_topk_mode
     |
     |  query_batch_size
     |
     |  thisown
     |      The membership flag
     |
     |  use_heap
     |       Select between using a heap or counting to select the k smallest values
     |      when scanning inverted lists.
     |
     |  xb
     |      database vectors, size ntotal * d / 8
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: uint8_t
     |      :param x:      training vectors, size n * d / 8
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryFromFloat(IndexBinary)
     |  IndexBinaryFromFloat(*args)
     |
     |   IndexBinary backed by a float Index.
     |
     |  Supports adding vertices and searching them.
     |
     |  All queries are symmetric because there is no distinction between codes and
     |  vectors.
     |
     |  Method resolution order:
     |      IndexBinaryFromFloat
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryFromFloat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  index
     |
     |  own_fields
     |      Whether object owns the index pointer.
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryHNSW(IndexBinary)
     |  IndexBinaryHNSW(*args)
     |
     |   The HNSW index is a normal random-access index with a HNSW
     |  link structure built on top
     |
     |  Method resolution order:
     |      IndexBinaryHNSW
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  get_distance_computer(self)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryHNSW(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryHNSWCagra(IndexBinaryHNSW)
     |  IndexBinaryHNSWCagra(*args)
     |
     |  Method resolution order:
     |      IndexBinaryHNSWCagra
     |      IndexBinaryHNSW
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryHNSWCagra(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  base_level_only
     |      When set to true, the index is immutable.
     |      This option is used to copy the knn graph from GpuIndexBinaryCagra
     |      to the base level of IndexBinaryHNSWCagra without adding upper levels.
     |      Doing so enables to search the HNSW index, but removes the
     |      ability to add vectors.
     |
     |  num_base_level_search_entrypoints
     |      When `base_level_only` is set to `True`, the search function
     |      searches only the base level knn graph of the HNSW index.
     |      This parameter selects the entry point by randomly selecting
     |      some points and using the best one.
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinaryHNSW:
     |
     |  get_distance_computer(self)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinaryHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryHash(IndexBinary)
     |  IndexBinaryHash(*args)
     |
     |  just uses the b first bits as a hash value
     |
     |  Method resolution order:
     |      IndexBinaryHash
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  hashtable_size(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryHash(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  b
     |
     |  invlists
     |
     |  nflip
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: uint8_t
     |      :param x:      training vectors, size n * d / 8
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryHashStats(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryHashStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n0
     |
     |  ndis
     |
     |  nlist
     |
     |  nq
     |
     |  thisown
     |      The membership flag

    class IndexBinaryIDMap(IndexBinary)
     |  IndexBinaryIDMap(*args)
     |
     |  Index that translates search results to ids
     |
     |  Method resolution order:
     |      IndexBinaryIDMap
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |      this will fail. Use add_with_ids
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, x, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      remove ids adapted to IndexFlat
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryIDMap(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  id_map
     |      whether pointers are deleted in destructor
     |
     |  index
     |
     |  own_fields
     |      the sub-index
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryIDMap2(IndexBinaryIDMap)
     |  IndexBinaryIDMap2(*args)
     |
     |  same as IndexIDMap but also provides an efficient reconstruction
     |  implementation via a 2-way index
     |
     |  Method resolution order:
     |      IndexBinaryIDMap2
     |      IndexBinaryIDMap
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_consistency(self)
     |      check that the rev_map and the id_map are in sync
     |
     |  construct_rev_map(self)
     |      make the rev_map from scratch
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryIDMap2(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  rev_map
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinaryIDMap:
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |      this will fail. Use add_with_ids
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, x, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinaryIDMap:
     |
     |  id_map
     |      whether pointers are deleted in destructor
     |
     |  index
     |
     |  own_fields
     |      the sub-index
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryIVF(IndexBinary)
     |  IndexBinaryIVF(*args)
     |
     |   Index based on a inverted file (IVF)
     |
     |  In the inverted file, the quantizer (an IndexBinary instance) provides a
     |  quantization index for each vector to be added. The quantization
     |  index maps to a list (aka inverted list or posting list), where the
     |  id of the vector is stored.
     |
     |  Otherwise the object is similar to the IndexIVF
     |
     |  Method resolution order:
     |      IndexBinaryIVF
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  add_core(self, n, x, xids, precomputed_idx)
     |       Implementation of vector addition where the vector assignments are
     |      predefined.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_InvertedListScanner(self, store_pairs=False)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, other, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_preassigned_c = range_search_preassigned(self, n, x, radius, assign, centroid_dis, result)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: uint8_t
     |      :param recons: output array of reconstructed vectors, size ni * d / 8
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d / 8)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None)
     |       Search a set of vectors, that are pre-quantized by the IVF
     |       quantizer. Fill in the corresponding heaps with the query
     |       results. search() calls this.
     |
     |      :type n: int
     |      :param n:      nb of vectors to query
     |      :type x: uint8_t
     |      :param x:      query vectors, size nx * d
     |      :type assign: int
     |      :param assign: coarse quantization indices, size nx * nprobe
     |      :type centroid_dis: int
     |      :param centroid_dis:
     |                        distances to coarse centroids, size nx * nprobe
     |      :param distance:
     |                        output distances, size n * k
     |      :type labels: int
     |      :param labels: output labels, size n * k
     |      :type store_pairs: boolean
     |      :param store_pairs: store inv list index + inv list offset
     |                              instead in upper/lower 32 bit of result,
     |                              instead of ids (used for reranking).
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params: used to override the object's search parameters
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryIVF(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  direct_map
     |      map for direct access to the elements. Enables reconstruct().
     |
     |  invlists
     |      Access to the actual data
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nlist
     |      number of possible key values
     |
     |  nprobe
     |      number of probes at query time
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  own_invlists
     |
     |  per_invlist_search
     |      collect computations per batch
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  thisown
     |      The membership flag
     |
     |  use_heap
     |       Select between using a heap or counting to select the k smallest values
     |      when scanning inverted lists.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryMultiHash(IndexBinary)
     |  IndexBinaryMultiHash(*args)
     |
     |  just uses the b first bits as a hash value
     |
     |  Method resolution order:
     |      IndexBinaryMultiHash
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |
     |  hashtable_size(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reset(self)
     |      Removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryMultiHash(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  b
     |      nb bits per hash map
     |
     |  maps
     |
     |  nflip
     |      nb bit flips to use at search time
     |
     |  nhash
     |      nb of hash maps
     |
     |  own_fields
     |
     |  storage
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: uint8_t
     |      :param x:      training vectors, size n * d / 8
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryReplicas(ThreadedIndexBaseBinary)
     |  IndexBinaryReplicas(*args)
     |
     |  Takes individual faiss::Index instances, and splits queries for
     |  sending to each Index instance, and joins the results together
     |  when done.
     |  Each index is managed by a separate CPU thread.
     |
     |  Method resolution order:
     |      IndexBinaryReplicas
     |      ThreadedIndexBaseBinary
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |      The dimension that all sub-indices must share will be the dimension of
     |      the first sub-index added
     |      :type threaded: boolean, optional
     |      :param threaded: do we use one thread per sub-index or do queries
     |          sequentially?
     |
     |      |
     |
     |      *Overload 2:*
     |      :type d: int
     |      :param d: the dimension that all sub-indices must share
     |      :type threaded: boolean, optional
     |      :param threaded: do we use one thread per sub index or do queries
     |          sequentially?
     |
     |      |
     |
     |      *Overload 3:*
     |      :type d: int
     |      :param d: the dimension that all sub-indices must share
     |      :param threaded: do we use one thread per sub index or do queries
     |          sequentially?
     |
     |      |
     |
     |      *Overload 4:*
     |      int version due to the implicit bool conversion ambiguity of int as
     |      dimension
     |
     |      |
     |
     |      *Overload 5:*
     |      int version due to the implicit bool conversion ambiguity of int as
     |      dimension
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  addIndex = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
     |
     |  add_c = add(self, n, x)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  add_replica(self, index)
     |      Alias for addIndex()
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, arg2, v)
     |      reconstructs from the first index
     |
     |  remove_replica(self, index)
     |      Alias for removeIndex()
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      faiss::Index API
     |      Query is partitioned into a slice for each sub-index
     |      split by ceil(n / #indices) for our sub-indices
     |
     |  syncWithSubIndexes(self)
     |      Synchronize the top-level index (IndexShards) with data in the
     |      sub-indices
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryReplicas(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ThreadedIndexBaseBinary:
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ThreadedIndexBaseBinary:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexBinaryShards(ThreadedIndexBaseBinary)
     |  IndexBinaryShards(*args)
     |
     |  Index that concatenates the results from several sub-indexes
     |
     |  Method resolution order:
     |      IndexBinaryShards
     |      ThreadedIndexBaseBinary
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |
     |      The dimension that all sub-indices must share will be the dimension of
     |      the first sub-index added
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :type successive_ids: boolean, optional
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 2:*
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :type successive_ids: boolean, optional
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 3:*
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 4:*
     |
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 5:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |      |
     |
     |      *Overload 6:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |      |
     |
     |      *Overload 7:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |      supported only for sub-indices that implement add_with_ids
     |
     |  add_shard = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      Cases (successive_ids, xids):
     |      - true, non-NULL       ERROR: it makes no sense to pass in ids and
     |                             request them to be shifted
     |      - true, NULL           OK: but should be called only once (calls add()
     |                             on sub-indexes).
     |      - false, non-NULL      OK: will call add_with_ids with passed in xids
     |                             distributed evenly over shards
     |      - false, NULL          OK: will call add_with_ids on each sub-index,
     |                             starting at ntotal
     |
     |  remove_shard(self, index)
     |      Alias for removeIndex()
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  syncWithSubIndexes(self)
     |      Synchronize the top-level index (IndexShards) with data in the
     |      sub-indices
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexBinaryShards(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  successive_ids
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ThreadedIndexBaseBinary:
     |
     |  addIndex(self, index)
     |      override an index that is managed by ourselves.
     |      WARNING: once an index is added, it becomes unsafe to touch it from any
     |      other thread than that on which is managing it, until we are shut
     |      down. Use runOnIndex to perform work on it instead.
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ThreadedIndexBaseBinary:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFastScan(Index)
     |  IndexFastScan(*args, **kwargs)
     |
     |   Fast scan version of IndexPQ and IndexAQ. Works for 4-bit PQ and AQ for now.
     |
     |  The codes are not stored sequentially but grouped in blocks of size bbs.
     |  This makes it possible to compute distances quickly with SIMD instructions.
     |  The trailing codes (padding codes that are added to complete the last code)
     |  are garbage.
     |
     |  Implementations:
     |  12: blocked loop with internal loop on Q with qbs
     |  13: same with reservoir accumulator to store results
     |  14: no qbs with heap accumulator
     |  15: no qbs with reservoir accumulator
     |
     |  Method resolution order:
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  fast_scan_code_size(self)
     |       Get the size of the code portion packed by pq4_pack_codes.
     |
     |      Returns the number of bytes per vector that are interleaved into
     |      SIMD blocks by pq4_pack_codes, excluding any embedded metadata
     |      (e.g., RaBitQ factors). The meaning of these bytes depends on the
     |      quantizer: for PQ/AQ they are 4-bit sub-quantizer nibbles, for
     |      RaBitQ they are 1-bit-per-dimension sign bits packed into nibbles.
     |
     |      Must be implemented by all derived classes.
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search for k nearest neighbors
     |
     |      :type n: int
     |      :param n:          number of query vectors
     |      :type x: float
     |      :param x:          query vectors (n * d)
     |      :type k: int
     |      :param k:          number of nearest neighbors to find
     |      :type distances: float
     |      :param distances:  output distances (n * k)
     |      :type labels: int
     |      :param labels:     output labels/indices (n * k)
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:     optional search parameters
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlat(IndexFlatCodes)
     |  IndexFlat(*args)
     |
     |  Index that stores the full vectors and performs exhaustive search
     |
     |  Method resolution order:
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_xb(self, *args)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlat1D(IndexFlatL2)
     |  IndexFlat1D(continuous_update=True)
     |
     |  optimized version for 1D "vectors".
     |
     |  Method resolution order:
     |      IndexFlat1D
     |      IndexFlatL2
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, continuous_update=True)
     |      :param d: dimensionality of the input vectors
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      Warn: the distances returned are L1 not L2
     |
     |  update_permutation(self)
     |      if not continuous_update, call this between the last add and
     |      the first search
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlat1D(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  continuous_update
     |      is the permutation updated continuously?
     |
     |  perm
     |      sorted database indices
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatL2:
     |
     |  clear_l2norms(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  sync_l2norms(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatL2:
     |
     |  cached_l2norms
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlat:
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_xb(self, *args)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlatCodes(Index)
     |  IndexFlatCodes(*args)
     |
     |   Index that encodes all vectors as fixed-size codes (size code_size). Storage
     |  is in the codes vector
     |
     |  Method resolution order:
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search implemented by decoding (most index types will have a faster
     |      implementation)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlatCodes(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlatIP(IndexFlat)
     |  IndexFlatIP(*args)
     |
     |  Method resolution order:
     |      IndexFlatIP
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlatIP(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlat:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_xb(self, *args)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlatIPPanorama(IndexFlatPanorama)
     |  IndexFlatIPPanorama(d_in, n_levels_in, batch_size_in=512)
     |
     |  Method resolution order:
     |      IndexFlatIPPanorama
     |      IndexFlatPanorama
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, d_in, n_levels_in, batch_size_in=512)
     |      :param d: dimensionality of the input vectors
     |      :param n_levels: number of Panorama levels
     |      :param batch_size: batch size for Panorama storage
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatPanorama
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes_in, xids) from IndexFlatPanorama
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatPanorama
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatPanorama
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatPanorama
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i, n, recons) from IndexFlatPanorama
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatPanorama
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None) from IndexFlatPanorama
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlatIPPanorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatPanorama:
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexFlatPanorama:
     |
     |  batch_size
     |
     |  n_levels
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatPanorama:
     |
     |  cum_sums
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlat:
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_xb(self, *args)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlatL2(IndexFlat)
     |  IndexFlatL2(*args)
     |
     |  Method resolution order:
     |      IndexFlatL2
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      :param d: dimensionality of the input vectors
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  clear_l2norms(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  sync_l2norms(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlatL2(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  cached_l2norms
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlat:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_xb(self, *args)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlatL2Panorama(IndexFlatPanorama)
     |  IndexFlatL2Panorama(d_in, n_levels_in, batch_size_in=512)
     |
     |  Method resolution order:
     |      IndexFlatL2Panorama
     |      IndexFlatPanorama
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, d_in, n_levels_in, batch_size_in=512)
     |      :param d: dimensionality of the input vectors
     |      :param n_levels: number of Panorama levels
     |      :param batch_size: batch size for Panorama storage
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatPanorama
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes_in, xids) from IndexFlatPanorama
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatPanorama
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatPanorama
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatPanorama
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i, n, recons) from IndexFlatPanorama
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatPanorama
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None) from IndexFlatPanorama
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlatL2Panorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatPanorama:
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexFlatPanorama:
     |
     |  batch_size
     |
     |  n_levels
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatPanorama:
     |
     |  cum_sums
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlat:
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_xb(self, *args)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexFlatPanorama(IndexFlat)
     |  IndexFlatPanorama(d_in, metric, n_levels_in, batch_size_in)
     |
     |  Method resolution order:
     |      IndexFlatPanorama
     |      IndexFlat
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, d_in, metric, n_levels_in, batch_size_in)
     |      :param d: dimensionality of the input vectors
     |      :type metric: int
     |      :param metric: metric type
     |      :param n_levels: number of Panorama levels
     |      :param batch_size: batch size for Panorama storage
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes_in, xids)
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i, n, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexFlatPanorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  batch_size
     |
     |  n_levels
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  cum_sums
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlat:
     |
     |  compute_distance_subset(self, n, x, k, distances, labels)
     |       compute distance with a subset of vectors
     |
     |      :type x: float
     |      :param x:       query vectors, size n * d
     |      :type labels: int
     |      :param labels:  indices of the vectors that should be compared
     |                         for each query vector, size n * k
     |      :type distances: float
     |      :param distances:
     |                         corresponding output distances, size n * k
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_xb(self, *args)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSW(Index)
     |  IndexHNSW(*args)
     |
     |   The HNSW index is a normal random-access index with a HNSW
     |  link structure built on top
     |
     |  Method resolution order:
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Adds vectors to the index. May not be called concurrently.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSW(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  thisown
     |      The membership flag
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSW2Level(IndexHNSW)
     |  IndexHNSW2Level(*args)
     |
     |  2-level code structure with fast random access
     |
     |  Method resolution order:
     |      IndexHNSW2Level
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  flip_to_ivf(self)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSW2Level(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexHNSW:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Adds vectors to the index. May not be called concurrently.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSWCagra(IndexHNSW)
     |  IndexHNSWCagra(*args)
     |
     |  Method resolution order:
     |      IndexHNSWCagra
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  get_numeric_type(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  set_numeric_type(self, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSWCagra(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  base_level_only
     |      When set to true, the index is immutable.
     |      This option is used to copy the knn graph from GpuIndexCagra
     |      to the base level of IndexHNSWCagra without adding upper levels.
     |      Doing so enables to search the HNSW index, but removes the
     |      ability to add vectors.
     |
     |  num_base_level_search_entrypoints
     |      When `base_level_only` is set to `True`, the search function
     |      searches only the base level knn graph of the HNSW index.
     |      This parameter selects the entry point by randomly selecting
     |      some points and using the best one.
     |
     |  numeric_type_
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexHNSW:
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSWFlat(IndexHNSW)
     |  IndexHNSWFlat(*args)
     |
     |  Flat index topped with with a HNSW structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexHNSWFlat
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSWFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexHNSW:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Adds vectors to the index. May not be called concurrently.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSWFlatPanorama(IndexHNSWFlat)
     |  IndexHNSWFlatPanorama(*args)
     |
     |   Panorama implementation of IndexHNSWFlat following
     |  https://www.arxiv.org/pdf/2510.00566.
     |
     |  Unlike cluster-based Panorama, the vectors have to be higher dimensional
     |  (i.e. typically d > 512) and/or be able to compress a lot of their energy in
     |  the early dimensions to be effective. This is because HNSW accesses vectors
     |  in a random order, which makes cache misses dominate the distance computation
     |  time.
     |
     |  The `num_panorama_levels` parameter controls the granularity of progressive
     |  distance refinement, allowing candidates to be eliminated early using partial
     |  distance computations rather than computing full distances.
     |
     |  NOTE: This version of HNSW handles search slightly differently than the
     |  vanilla HNSW, as it uses partial distance computations with progressive
     |  refinement bounds. Instead of computing full distances immediately for all
     |  candidates, Panorama maintains lower and upper bounds that are incrementally
     |  tightened across refinement levels. Candidates are inserted into the search
     |  beam using approximate distance estimates (LB+UB)/2 and are only fully
     |  evaluated when they survive pruning and enter the result heap. This allows
     |  the algorithm to prune unpromising candidates early using Cauchy-Schwarz
     |  bounds on partial inner products. Hence, recall is not guaranteed to be the
     |  same as vanilla HNSW due to the heterogeneous precision within the search
     |  beam (exact vs. partial distance estimates affecting traversal order).
     |
     |  Method resolution order:
     |      IndexHNSWFlatPanorama
     |      IndexHNSWFlat
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  get_cum_sum(self, i)
     |      Inline for performance - called frequently in search hot path.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSWFlatPanorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  num_panorama_levels
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  cum_sums
     |
     |  pano
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexHNSW:
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSWPQ(IndexHNSW)
     |  IndexHNSWPQ(*args)
     |
     |  PQ index topped with with a HNSW structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexHNSWPQ
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSWPQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexHNSW:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Adds vectors to the index. May not be called concurrently.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexHNSWSQ(IndexHNSW)
     |  IndexHNSWSQ(*args)
     |
     |  SQ index topped with a HNSW structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexHNSWSQ
     |      IndexHNSW
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexHNSWSQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexHNSW:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Adds vectors to the index. May not be called concurrently.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  init_level_0_from_entry_points(self, npt, points, nearests)
     |      alternative graph building
     |
     |  init_level_0_from_knngraph(self, k, D, I)
     |      alternative graph building
     |
     |  link_singletons(self)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reorder_links(self)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1, params=None)
     |       Perform search only on level 0, given the starting points for
     |      each vertex.
     |
     |      :type search_type: int, optional
     |      :param search_type: 1:perform one search per nprobe, 2: enqueue
     |                             all entry points
     |
     |  shrink_level_0_neighbors(self, size)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexHNSW:
     |
     |  hnsw
     |
     |  init_level0
     |
     |  keep_max_size_level0
     |
     |  own_fields
     |
     |  retain_locks
     |
     |  storage
     |
     |  use_visited_hashset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexIDMap(Index)
     |  IndexIDMap(*args)
     |
     |  Index that translates search results to ids
     |
     |  Method resolution order:
     |      IndexIDMap
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      this will fail. Use add_with_ids
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      remove ids adapted to IndexFlat
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIDMap(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  id_map
     |      whether pointers are deleted in destructor
     |
     |  index
     |
     |  own_fields
     |      the sub-index
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexIDMap2(IndexIDMap)
     |  IndexIDMap2(*args)
     |
     |  same as IndexIDMap but also provides an efficient reconstruction
     |  implementation via a 2-way index
     |
     |  Method resolution order:
     |      IndexIDMap2
     |      IndexIDMap
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_consistency(self)
     |      check that the rev_map and the id_map are in sync
     |
     |  construct_rev_map(self)
     |      make the rev_map from scratch
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIDMap2(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  rev_map
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIDMap:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      this will fail. Use add_with_ids
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIDMap:
     |
     |  id_map
     |      whether pointers are deleted in destructor
     |
     |  index
     |
     |  own_fields
     |      the sub-index
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexIVF(Index, IndexIVFInterface)
     |  IndexIVF(*args, **kwargs)
     |
     |   Index based on a inverted file (IVF)
     |
     |  In the inverted file, the quantizer (an Index instance) provides a
     |  quantization index for each vector to be added. The quantization
     |  index maps to a list (aka inverted list or posting list), where the
     |  id of the vector is stored.
     |
     |  The inverted list object is required only after training. If none is
     |  set externally, an ArrayInvertedLists is used automatically.
     |
     |  At search time, the vector to be searched is also quantized, and
     |  only the list corresponding to the quantization index is
     |  searched. This speeds up the search by making it
     |  non-exhaustive. This can be relaxed using multi-probe search: a few
     |  (nprobe) quantization indices are selected and several inverted
     |  lists are visited.
     |
     |  Sub-classes implement a post-filtering of the index that refines
     |  the distance estimation from the query to database vectors.
     |
     |  Method resolution order:
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_CodePacker(self)
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVF(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFAdditiveQuantizer(IndexIVF)
     |  IndexIVFAdditiveQuantizer(*args)
     |
     |  Abstract class for IVF additive quantizers.
     |  The search functions are in common.
     |
     |  Method resolution order:
     |      IndexIVFAdditiveQuantizer
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFAdditiveQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  aq
     |
     |  thisown
     |      The membership flag
     |
     |  use_precomputed_table
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFAdditiveQuantizerFastScan(IndexIVFFastScan)
     |  IndexIVFAdditiveQuantizerFastScan(*args)
     |
     |   Fast scan version of IVFAQ. Works for 4-bit AQ for now.
     |
     |  The codes in the inverted lists are not stored sequentially but
     |  grouped in blocks of size bbs. This makes it possible to very quickly
     |  compute distances with SIMD instructions.
     |
     |  Implementations (implem):
     |  0: auto-select implementation (default)
     |  1: orig's search, re-implemented
     |  2: orig's search, re-ordered by invlist
     |  10: optimizer int16 search, collect results in heap, no qbs
     |  11: idem, collect results in reservoir
     |  12: optimizer int16 search, collect results in heap, uses qbs
     |  13: idem, collect results in reservoir
     |
     |  Method resolution order:
     |      IndexIVFAdditiveQuantizerFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from IndexIVFFastScan
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |      same as the regular IVFAQ encoder. The codes are not reorganized by
     |      blocks a that point
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, aq, nlist, metric, bbs, own_invlists)
     |
     |  lookup_table_is_3d(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexIVFFastScan
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from IndexIVFFastScan
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from IndexIVFFastScan
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFAdditiveQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFFastScan(IndexIVF)
     |  IndexIVFFastScan(*args, **kwargs)
     |
     |   Fast scan version of IVFPQ and IVFAQ. Works for 4-bit PQ/AQ for now.
     |
     |  The codes in the inverted lists are not stored sequentially but
     |  grouped in blocks of size bbs. This makes it possible to very quickly
     |  compute distances with SIMD instructions.
     |
     |  Implementations (implem):
     |  0: auto-select implementation (default)
     |  1: orig's search, re-implemented
     |  2: orig's search, re-ordered by invlist
     |  10: optimizer int16 search, collect results in heap, no qbs
     |  11: idem, collect results in reservoir
     |  12: optimizer int16 search, collect results in heap, uses qbs
     |  13: idem, collect results in reservoir
     |  14: internally multithreaded implem over nq * nprobe
     |  15: same with reservoir
     |
     |  For range search, only 10 and 12 are supported.
     |  add 100 to the implem to force single-thread scanning (the coarse quantizer
     |  may still use multiple threads).
     |
     |  Method resolution order:
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  fast_scan_code_size(self)
     |       Get the size of the code portion packed by pq4_pack_codes.
     |
     |      Returns the number of bytes per vector that are interleaved into
     |      SIMD blocks by pq4_pack_codes, excluding any embedded metadata
     |      (e.g., RaBitQ factors). The meaning of these bytes depends on the
     |      quantizer: for PQ/AQ they are 4-bit sub-quantizer nibbles, for
     |      RaBitQ they are 1-bit-per-dimension sign bits packed into nibbles.
     |
     |      Must be implemented by all derived classes.
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  lookup_table_is_3d(self)
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search for k nearest neighbors
     |
     |      :type n: int
     |      :param n:          number of query vectors
     |      :type x: float
     |      :param x:          query vectors (n * d)
     |      :type k: int
     |      :param k:          number of nearest neighbors to find
     |      :type distances: float
     |      :param distances:  output distances (n * k)
     |      :type labels: int
     |      :param labels:     output labels/indices (n * k)
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:     optional search parameters
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFFlat(IndexIVF)
     |  IndexIVFFlat(*args)
     |
     |   Inverted file with stored vectors. Here the inverted file
     |  pre-selects the vectors to be searched, but they are not otherwise
     |  encoded, the code array just contains the raw float entries.
     |
     |  Method resolution order:
     |      IndexIVFFlat
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFFlatDedup(IndexIVFFlat)
     |  IndexIVFFlatDedup(*args)
     |
     |  Method resolution order:
     |      IndexIVFFlatDedup
     |      IndexIVFFlat
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      implemented for all IndexIVF* classes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |      not implemented
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |      not implemented
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      also dedups the training set
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |      not implemented
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFFlatDedup(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFlat:
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  set_direct_map_type(self, type)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFFlatPanorama(IndexIVFFlat)
     |  IndexIVFFlatPanorama(*args)
     |
     |  Panorama adaptation of IndexIVFFlat following
     |  https://www.arxiv.org/pdf/2510.00566.
     |
     |  IDEA:
     |  Panorama adapts the storage layout within each cluster and uses
     |  pruning with bounds to improve the search performance.
     |  Combined with orthogonal transforms upstream that concentrate the energy
     |  in the early dimensions (like PCA, Cayley, etc.), Panorama can prune up
     |  to 95% of the vectors in the cluster.
     |
     |  OVERHEAD:
     |  To be more efficient, we compute the residual energies at insertion time
     |  and store them along the vectors, which comes with an additional storage
     |  overhead of exactly (nlevels + 1) floats per vector. Add time is also
     |  slightly higher due to the overhead of transposing the vectors.
     |
     |  NOTE:
     |  We inherit from IndexIVFFlat instead of IndexIVF so we can keep the same
     |  insertion logic. The code responsible for level-oriented storage is in
     |  `ArrayInvertedListsPanorama`, which is a struct member of `IndexIVF`.
     |
     |  Method resolution order:
     |      IndexIVFFlatPanorama
     |      IndexIVFFlat
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFFlatPanorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  batch_size
     |
     |  cum_sums
     |
     |  n_levels
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFlat:
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFIndependentQuantizer(Index)
     |  IndexIVFIndependentQuantizer(*args)
     |
     |   An IVF index with a quantizer that has a different input dimension from the
     |  payload size. The vectors to encode are obtained from the input vectors by a
     |  VectorTransform.
     |
     |  Method resolution order:
     |      IndexIVFIndependentQuantizer
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFIndependentQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  index_ivf
     |      the IVF index, controls nlist and nprobe
     |
     |  own_fields
     |      whether *this owns the 3 fields
     |
     |  quantizer
     |      quantizer is fed directly with the input vectors
     |
     |  thisown
     |      The membership flag
     |
     |  vt
     |      transform before the IVF vectors are applied
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexIVFInterface(Level1Quantizer)
     |  IndexIVFInterface(*args, **kwargs)
     |
     |  Method resolution order:
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |       Range search a set of vectors, that are pre-quantized by the IVF
     |       quantizer. Fill in the RangeSearchResults results. The default
     |      implementation uses InvertedListScanners to do the search.
     |
     |      :param n:      nb of vectors to query
     |      :type x: float
     |      :param x:      query vectors, size nx * d
     |      :param assign: coarse quantization indices, size nx * nprobe
     |      :param centroid_dis:
     |                        distances to coarse centroids, size nx * nprobe
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result: Output results
     |      :type store_pairs: boolean, optional
     |      :param store_pairs: store inv list index + inv list offset
     |                              instead in upper/lower 32 bit of result,
     |                              instead of ids (used for reranking).
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params: used to override the object's search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:  search stats to be updated (can be null)
     |
     |  search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |       search a set of vectors, that are pre-quantized by the IVF
     |       quantizer. Fill in the corresponding heaps with the query
     |       results. The default implementation uses InvertedListScanners
     |       to do the search.
     |
     |      :type n: int
     |      :param n:      nb of vectors to query
     |      :type x: float
     |      :param x:      query vectors, size nx * d
     |      :type assign: int
     |      :param assign: coarse quantization indices, size nx * nprobe
     |      :type centroid_dis: float
     |      :param centroid_dis:
     |                        distances to coarse centroids, size nx * nprobe
     |      :param distance:
     |                        output distances, size n * k
     |      :type labels: int
     |      :param labels: output labels, size n * k
     |      :type store_pairs: boolean
     |      :param store_pairs: store inv list index + inv list offset
     |                              instead in upper/lower 32 bit of result,
     |                              instead of ids (used for reranking).
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params: used to override the object's search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:  search stats to be updated (can be null)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFInterface(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFLocalSearchQuantizer(IndexIVFAdditiveQuantizer)
     |  IndexIVFLocalSearchQuantizer(*args)
     |
     |   IndexIVF based on a residual quantizer. Stored vectors are
     |  approximated by residual quantization codes.
     |
     |  Method resolution order:
     |      IndexIVFLocalSearchQuantizer
     |      IndexIVFAdditiveQuantizer
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFLocalSearchQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lsq
     |      The LSQ quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizer:
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
     |
     |  aq
     |
     |  use_precomputed_table
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFLocalSearchQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
     |  IndexIVFLocalSearchQuantizerFastScan(*args)
     |
     |  Method resolution order:
     |      IndexIVFLocalSearchQuantizerFastScan
     |      IndexIVFAdditiveQuantizerFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFLocalSearchQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lsq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from IndexIVFFastScan
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |      same as the regular IVFAQ encoder. The codes are not reorganized by
     |      blocks a that point
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, aq, nlist, metric, bbs, own_invlists)
     |
     |  lookup_table_is_3d(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexIVFFastScan
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from IndexIVFFastScan
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from IndexIVFFastScan
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFPQ(IndexIVF)
     |  IndexIVFPQ(*args)
     |
     |   Inverted file with Product Quantizer encoding. Each residual
     |  vector is encoded as a product quantizer code.
     |
     |  Method resolution order:
     |      IndexIVFPQ
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_core_o(self, n, x, xids, residuals_2, precomputed_idx=None, inverted_list_context=None)
     |      same as add_core, also:
     |      - output 2nd level residuals if residuals_2 != NULL
     |      - accepts precomputed_idx = nullptr
     |
     |  decode_multiple(self, n, keys, xcodes, x)
     |      inverse of encode_multiple
     |
     |  decode_vectors(self, n, codes, listnos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode(self, key, x, code)
     |
     |  encode_multiple(self, n, keys, x, codes, compute_keys=False)
     |       Encode multiple vectors
     |
     |      :type n: int
     |      :param n:       nb vectors to encode
     |      :type keys: int
     |      :param keys:    posting list ids for those vectors (size n)
     |      :type x: float
     |      :param x:       vectors (size n * d)
     |      :type codes: uint8_t
     |      :param codes:   output codes (size n * code_size)
     |      :type compute_keys: boolean, optional
     |      :param compute_keys:  if false, assume keys are precomputed,
     |                               otherwise compute them
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  find_duplicates(self, ids, lims)
     |       Find exact duplicates in the dataset.
     |
     |      the duplicates are returned in pre-allocated arrays (see the
     |      max sizes).
     |
     |      :type lims: int
     |      :param lims:   limits between groups of duplicates
     |                         (max size ntotal / 2 + 1)
     |      :type ids: int
     |      :param ids:    ids[lims[i]] : ids[lims[i+1]-1] is a group of
     |                         duplicates (max size ntotal)
     |      :rtype: int
     |      :return: n      number of groups found
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  precompute_table(self)
     |      build precomputed table
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  train_encoder(self, n, x, assign)
     |      trains the product quantizer
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFPQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  do_polysemous_training
     |      reorder PQ centroids after training?
     |
     |  polysemous_ht
     |      Hamming thresh for polysemous filtering
     |
     |  polysemous_training
     |      if NULL, use default
     |
     |  pq
     |      produces the codes
     |
     |  precomputed_table
     |      if use_precompute_table
     |      size nlist * pq.M * pq.ksub
     |
     |  scan_table_threshold
     |      use table computation or on-the-fly?
     |
     |  thisown
     |      The membership flag
     |
     |  use_precomputed_table
     |       Precompute table that speed up query preprocessing at some
     |      memory cost (used only for by_residual with L2 metric)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFPQFastScan(IndexIVFFastScan)
     |  IndexIVFPQFastScan(*args)
     |
     |   Fast scan version of IVFPQ. Works for 4-bit PQ for now.
     |
     |  The codes in the inverted lists are not stored sequentially but
     |  grouped in blocks of size bbs. This makes it possible to very quickly
     |  compute distances with SIMD instructions.
     |
     |  Implementations (implem):
     |  0: auto-select implementation (default)
     |  1: orig's search, re-implemented
     |  2: orig's search, re-ordered by invlist
     |  10: optimizer int16 search, collect results in heap, no qbs
     |  11: idem, collect results in reservoir
     |  12: optimizer int16 search, collect results in heap, uses qbs
     |  13: idem, collect results in reservoir
     |
     |  Method resolution order:
     |      IndexIVFPQFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |      same as the regular IVFPQ encoder. The codes are not reorganized by
     |      blocks a that point
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit PQ sub-quantizer nibbles)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, arg4)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  lookup_table_is_3d(self)
     |
     |  precompute_table(self)
     |      build precomputed table, possibly updating use_precomputed_table
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFPQFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  pq
     |      produces the codes
     |
     |  precomputed_table
     |      if use_precompute_table size (nlist, pq.M, pq.ksub)
     |
     |  thisown
     |      The membership flag
     |
     |  use_precomputed_table
     |      precomputed tables management
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search for k nearest neighbors
     |
     |      :type n: int
     |      :param n:          number of query vectors
     |      :type x: float
     |      :param x:          query vectors (n * d)
     |      :type k: int
     |      :param k:          number of nearest neighbors to find
     |      :type distances: float
     |      :param distances:  output distances (n * k)
     |      :type labels: int
     |      :param labels:     output labels/indices (n * k)
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:     optional search parameters
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFPQR(IndexIVFPQ)
     |  IndexIVFPQR(*args)
     |
     |  Index with an additional level of PQ refinement
     |
     |  Method resolution order:
     |      IndexIVFPQR
     |      IndexIVFPQ
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |      same as add_with_ids, but optionally use the precomputed list ids
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  train_encoder(self, n, x, assign)
     |      trains the two product quantizers
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFPQR(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  k_factor
     |      factor between k requested in search and the k requested from the IVFPQ
     |
     |  refine_codes
     |      corresponding codes
     |
     |  refine_pq
     |      3rd level quantizer
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFPQ:
     |
     |  add_core_o(self, n, x, xids, residuals_2, precomputed_idx=None, inverted_list_context=None)
     |      same as add_core, also:
     |      - output 2nd level residuals if residuals_2 != NULL
     |      - accepts precomputed_idx = nullptr
     |
     |  decode_multiple(self, n, keys, xcodes, x)
     |      inverse of encode_multiple
     |
     |  decode_vectors(self, n, codes, listnos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode(self, key, x, code)
     |
     |  encode_multiple(self, n, keys, x, codes, compute_keys=False)
     |       Encode multiple vectors
     |
     |      :type n: int
     |      :param n:       nb vectors to encode
     |      :type keys: int
     |      :param keys:    posting list ids for those vectors (size n)
     |      :type x: float
     |      :param x:       vectors (size n * d)
     |      :type codes: uint8_t
     |      :param codes:   output codes (size n * code_size)
     |      :type compute_keys: boolean, optional
     |      :param compute_keys:  if false, assume keys are precomputed,
     |                               otherwise compute them
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  find_duplicates(self, ids, lims)
     |       Find exact duplicates in the dataset.
     |
     |      the duplicates are returned in pre-allocated arrays (see the
     |      max sizes).
     |
     |      :type lims: int
     |      :param lims:   limits between groups of duplicates
     |                         (max size ntotal / 2 + 1)
     |      :type ids: int
     |      :param ids:    ids[lims[i]] : ids[lims[i+1]-1] is a group of
     |                         duplicates (max size ntotal)
     |      :rtype: int
     |      :return: n      number of groups found
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  precompute_table(self)
     |      build precomputed table
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFPQ:
     |
     |  do_polysemous_training
     |      reorder PQ centroids after training?
     |
     |  polysemous_ht
     |      Hamming thresh for polysemous filtering
     |
     |  polysemous_training
     |      if NULL, use default
     |
     |  pq
     |      produces the codes
     |
     |  precomputed_table
     |      if use_precompute_table
     |      size nlist * pq.M * pq.ksub
     |
     |  scan_table_threshold
     |      use table computation or on-the-fly?
     |
     |  use_precomputed_table
     |       Precompute table that speed up query preprocessing at some
     |      memory cost (used only for by_residual with L2 metric)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFPQStats(builtins.object)
     |  statistics are robust to internal threading, but not if
     |  IndexIVFPQ::search_preassigned is called by multiple threads
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFPQStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n_hamming_pass
     |      nb of passed Hamming distance tests (for polysemous)
     |
     |  nrefine
     |      nb of refines (IVFPQR)
     |
     |  refine_cycles
     |      only for IVFPQR
     |
     |  search_cycles
     |
     |  thisown
     |      The membership flag

    class IndexIVFProductLocalSearchQuantizer(IndexIVFAdditiveQuantizer)
     |  IndexIVFProductLocalSearchQuantizer(*args)
     |
     |   IndexIVF based on a product local search quantizer. Stored vectors are
     |  approximated by product local search quantization codes.
     |
     |  Method resolution order:
     |      IndexIVFProductLocalSearchQuantizer
     |      IndexIVFAdditiveQuantizer
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of local search quantizers
     |      :type Msub: int
     |      :param Msub:   number of subquantizers per LSQ
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFProductLocalSearchQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  plsq
     |      The product local search quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizer:
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
     |
     |  aq
     |
     |  use_precomputed_table
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFProductLocalSearchQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
     |  IndexIVFProductLocalSearchQuantizerFastScan(*args)
     |
     |  Method resolution order:
     |      IndexIVFProductLocalSearchQuantizerFastScan
     |      IndexIVFAdditiveQuantizerFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFProductLocalSearchQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  plsq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from IndexIVFFastScan
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |      same as the regular IVFAQ encoder. The codes are not reorganized by
     |      blocks a that point
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, aq, nlist, metric, bbs, own_invlists)
     |
     |  lookup_table_is_3d(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexIVFFastScan
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from IndexIVFFastScan
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from IndexIVFFastScan
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFProductResidualQuantizer(IndexIVFAdditiveQuantizer)
     |  IndexIVFProductResidualQuantizer(*args)
     |
     |   IndexIVF based on a product residual quantizer. Stored vectors are
     |  approximated by product residual quantization codes.
     |
     |  Method resolution order:
     |      IndexIVFProductResidualQuantizer
     |      IndexIVFAdditiveQuantizer
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of residual quantizers
     |      :type Msub: int
     |      :param Msub:   number of subquantizers per RQ
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFProductResidualQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  prq
     |      The product residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizer:
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
     |
     |  aq
     |
     |  use_precomputed_table
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFProductResidualQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
     |  IndexIVFProductResidualQuantizerFastScan(*args)
     |
     |  Method resolution order:
     |      IndexIVFProductResidualQuantizerFastScan
     |      IndexIVFAdditiveQuantizerFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFProductResidualQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  prq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from IndexIVFFastScan
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |      same as the regular IVFAQ encoder. The codes are not reorganized by
     |      blocks a that point
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, aq, nlist, metric, bbs, own_invlists)
     |
     |  lookup_table_is_3d(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexIVFFastScan
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from IndexIVFFastScan
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from IndexIVFFastScan
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFRaBitQ(IndexIVF)
     |  IndexIVFRaBitQ(*args)
     |
     |  Method resolution order:
     |      IndexIVFRaBitQ
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFRaBitQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  qb
     |
     |  rabitq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFRaBitQFastScan(IndexIVFFastScan)
     |  IndexIVFRaBitQFastScan(*args)
     |
     |   Fast-scan version of IndexIVFRaBitQ that processes vectors in batches
     |  using SIMD operations. Combines the inverted file structure of IVF
     |  with RaBitQ's bit-level quantization and FastScan's batch processing.
     |
     |  Key features:
     |  - Inherits from IndexIVFFastScan for IVF structure and search algorithms
     |  - Processes 32 database vectors at a time using SIMD
     |  - Separates factors from quantized bits for efficient processing
     |  - Supports both L2 and inner product metrics
     |  - Maintains compatibility with existing IVF search parameters
     |
     |  Implementation details:
     |  - Batch size (bbs) is typically 32 for optimal SIMD performance
     |  - Factors are stored separately from packed codes for cache efficiency
     |  - Query factors are computed once per search and reused across lists
     |  - Uses specialized result handlers for RaBitQ distance corrections
     |
     |  Method resolution order:
     |      IndexIVFRaBitQFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |      Override: compute and quantize LUT per-query to avoid O(n*nprobe*M*16)
     |      float table allocation.
     |
     |  compute_per_vector_storage_size(self)
     |      Compute per-vector auxiliary storage size based on nb_bits
     |
     |  compute_residual_LUT(self, query, centroid_id, query_factors, lut_out, qb_param, centered_param, rotated_q, centroid_buf)
     |      Compute residual, query factors, and float LUT in two passes over d.
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: (d + 7) / 8 bytes (1-bit-per-dimension sign bits,
     |      excluding factors)
     |
     |  get_CodePacker(self)
     |      Return CodePackerRaBitQ with enlarged block size
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |      Get an InvertedListScanner for single-query scanning.
     |      This provides compatibility with the standard IVF search interface
     |
     |  lookup_table_is_3d(self)
     |      Implementation methods for IVFRaBitQFastScan specialization
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |      Write per-vector auxiliary data into block auxiliary region
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |      Reconstruct a single vector from an inverted list
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |      Override sa_decode to handle RaBitQ reconstruction
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFRaBitQFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centered
     |      Use zero-centered scalar quantizer for queries
     |
     |  qb
     |      Default number of bits to quantize a query with
     |
     |  rabitq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_orig_invlists(self)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search for k nearest neighbors
     |
     |      :type n: int
     |      :param n:          number of query vectors
     |      :type x: float
     |      :param x:          query vectors (n * d)
     |      :type k: int
     |      :param k:          number of nearest neighbors to find
     |      :type distances: float
     |      :param distances:  output distances (n * k)
     |      :type labels: int
     |      :param labels:     output labels/indices (n * k)
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:     optional search parameters
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFResidualQuantizer(IndexIVFAdditiveQuantizer)
     |  IndexIVFResidualQuantizer(*args)
     |
     |   IndexIVF based on a residual quantizer. Stored vectors are
     |  approximated by residual quantization codes.
     |
     |  Method resolution order:
     |      IndexIVFResidualQuantizer
     |      IndexIVFAdditiveQuantizer
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFResidualQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  rq
     |      The residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizer:
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizer:
     |
     |  aq
     |
     |  use_precomputed_table
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFResidualQuantizerFastScan(IndexIVFAdditiveQuantizerFastScan)
     |  IndexIVFResidualQuantizerFastScan(*args)
     |
     |  Method resolution order:
     |      IndexIVFResidualQuantizerFastScan
     |      IndexIVFAdditiveQuantizerFastScan
     |      IndexIVFFastScan
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFResidualQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  rq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from IndexIVFFastScan
     |       Add vectors with specific IDs to the index
     |
     |      :type n: int
     |      :param n:     number of vectors to add
     |      :type x: float
     |      :param x:     vectors to add (n * d)
     |      :type xids: int
     |      :param xids:  IDs for the vectors (n)
     |
     |  compute_LUT(self, n, x, cq, dis_tables, biases, context)
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listno=False)
     |      same as the regular IVFAQ encoder. The codes are not reorganized by
     |      blocks a that point
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, aq, nlist, metric, bbs, own_invlists)
     |
     |  lookup_table_is_3d(self)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexIVFFastScan
     |       Range search for all neighbors within radius
     |
     |      :type n: int
     |      :param n:       number of query vectors
     |      :type x: float
     |      :param x:       query vectors (n * d)
     |      :type radius: float
     |      :param radius:  search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:  output range search results
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:  optional search parameters
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from IndexIVFFastScan
     |       Decode a set of vectors
     |
     |      NOTE: The codes in the IndexFastScan object are non-contiguous.
     |            But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None) from IndexIVFFastScan
     |       Search with pre-assigned coarse quantization
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type k: int
     |      :param k:             number of nearest neighbors to find
     |      :type assign: int
     |      :param assign:        coarse cluster assignments (n * nprobe)
     |      :type centroid_dis: float
     |      :param centroid_dis:  distances to centroids (n * nprobe)
     |      :type distances: float
     |      :param distances:     output distances (n * k)
     |      :type labels: int
     |      :param labels:        output labels/indices (n * k)
     |      :type store_pairs: boolean
     |      :param store_pairs:   whether to store cluster-relative pairs
     |      :type params: :py:class:`IVFSearchParameters`, optional
     |      :param params:        optional IVF search parameters
     |      :type stats: :py:class:`IndexIVFStats`, optional
     |      :param stats:         optional search statistics
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVFFastScan:
     |
     |  compute_LUT_uint8(self, n, x, cq, dis_tables, biases, normalizers, context)
     |       Compute quantized lookup tables for distance computation
     |
     |      :type n: int
     |      :param n:             number of query vectors
     |      :type x: float
     |      :param x:             query vectors (n * d)
     |      :type cq: faiss::IndexIVFFastScan::CoarseQuantized
     |      :param cq:            coarse quantization results
     |      :type dis_tables: faiss::AlignedTable< uint8_t >
     |      :param dis_tables:    output quantized distance tables
     |      :type biases: faiss::AlignedTable< uint16_t >
     |      :param biases:        output quantized bias values
     |      :type normalizers: float
     |      :param normalizers:   output normalization factors
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:       processing context containing query factors
     |          processor
     |
     |  get_CodePacker(self)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_code_packer(self)
     |
     |  init_fastscan(self, fine_quantizer, M, nbits, nlist, metric, bbs, own_invlists)
     |       Initialize the fast scan functionality (called by implementations)
     |
     |      :type fine_quantizer: :py:class:`Quantizer`
     |      :param fine_quantizer:  fine quantizer for encoding
     |      :type M: int
     |      :param M:               number of subquantizers
     |      :type nbits: int
     |      :param nbits:           number of bits per subquantizer
     |      :type nlist: int
     |      :param nlist:           number of inverted lists
     |      :type metric: int
     |      :param metric:          distance metric to use
     |      :type bbs: int
     |      :param bbs:             block size for SIMD processing
     |      :type own_invlists: boolean
     |      :param own_invlists:    whether to own the inverted lists
     |
     |  postprocess_packed_codes(self, list_no, list_offset, n_added, flat_codes)
     |       Post-process packed codes after pq4_pack_codes_range.
     |
     |      Called during add_with_ids after codes have been packed into
     |      SIMD-friendly blocks.
     |
     |      :type list_no: int
     |      :param list_no:       inverted list number
     |      :type list_offset: int
     |      :param list_offset:   starting offset within the list (pre-existing size)
     |      :type n_added: int
     |      :param n_added:       number of vectors added in this batch
     |      :type flat_codes: uint8_t
     |      :param flat_codes:    encoded vectors for this batch (n_added * code_size)
     |
     |  range_search_dispatch_implem(self, n, x, radius, rres, cq_in, context, params=None)
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_orig_invlists(self)
     |
     |  search_dispatch_implem(self, n, x, k, distances, labels, cq, context, params=None)
     |
     |  search_implem_14(self, n, x, k, distances, labels, cq, impl, context, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  fine_quantizer
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  orig_invlists
     |      orig's inverted lists (for debugging)
     |
     |  qbs
     |
     |  qbs2
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_InvertedListScanner(self, store_pairs=False, sel=None, params=None)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFScalarQuantizer(IndexIVF)
     |  IndexIVFScalarQuantizer(*args)
     |
     |  Method resolution order:
     |      IndexIVFScalarQuantizer
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFScalarQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  sq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFSpectralHash(IndexIVF)
     |  IndexIVFSpectralHash(*args)
     |
     |   Inverted list that stores binary codes of size nbit. Before the
     |  binary conversion, the dimension of the vectors is transformed from
     |  dim d into dim nbit by vt (a random rotation by default).
     |
     |  Each coordinate is subtracted from a value determined by
     |  threshold_type, and split into intervals of size period. Half of
     |  the interval is a 0 bit, the other half a 1.
     |
     |  Method resolution order:
     |      IndexIVFSpectralHash
     |      IndexIVF
     |      Index
     |      IndexIVFInterface
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  encode_vectors(self, n, x, list_nos, codes, include_listnos=False)
     |       Encodes a set of vectors as they would appear in the inverted lists
     |
     |      :type list_nos: int
     |      :param list_nos:   inverted list ids as returned by the
     |                            quantizer (size n). -1s are ignored.
     |      :type codes: uint8_t
     |      :param codes:      output codes, size n * code_size
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  get_InvertedListScanner(self, store_pairs, sel, params)
     |       Get a scanner for this index (store_pairs means ignore labels)
     |
     |      The default search implementation uses this to compute the distances.
     |      Use sel instead of params->sel, because sel is initialized with
     |      params->sel, but may get overridden by IndexIVF's internal logic.
     |
     |  replace_vt = replacement_method(self, ref, own=False) from faiss.add_ref_in_method_explicit_own.<locals>
     |
     |  train_encoder(self, n, x, assign)
     |       Train the encoder for the vectors.
     |
     |      If by_residual then it is called with residuals and corresponding assign
     |      array, otherwise x is the raw training vectors and assign=nullptr
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFSpectralHash(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  nbit
     |      nb of bits of the binary signature
     |
     |  own_fields
     |      own the vt
     |
     |  period
     |      interval size for 0s and 1s
     |
     |  thisown
     |      The membership flag
     |
     |  threshold_type
     |
     |  trained
     |      Trained threshold.
     |      size nlist * nbit or 0 if Thresh_global
     |
     |  vt
     |      transformation from d to nbit dim
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  Thresh_centroid = 1
     |
     |  Thresh_centroid_half = 2
     |
     |  Thresh_global = 0
     |
     |  Thresh_median = 3
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexIVF:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      Calls add_with_ids with NULL ids
     |
     |  add_core(self, n, x, xids, precomputed_idx, inverted_list_context=None)
     |       Implementation of vector addition where the vector assignments are
     |      predefined. The default implementation hands over the code extraction to
     |      encode_vectors.
     |
     |      :type precomputed_idx: int
     |      :param precomputed_idx:    quantization indices for the input vectors
     |          (size n)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      default implementation that calls encode_vectors
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  check_ids_sorted(self)
     |      are the ids sorted?
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      see Invlists::copy_subset_to for the meaning of subset_type
     |
     |  decode_vectors(self, n, codes, list_nos, x)
     |       Decodes a set of vectors as they would appear in a given set of inverted
     |      lists (inverse of encode_vectors)
     |
     |      :type codes: uint8_t
     |      :param codes:      input codes, size n * code_size
     |      :type x: float
     |      :param x:          output decoded vectors
     |      :type list_nos: int
     |      :param list_nos:   input listnos, size n
     |
     |  get_CodePacker(self)
     |
     |  get_list_size(self, list_no)
     |
     |  make_direct_map(self, new_maintain_direct_map=True)
     |       initialize a direct map
     |
     |      :type new_maintain_direct_map: boolean, optional
     |      :param new_maintain_direct_map:    if true, create a direct map,
     |                                            else clear it
     |
     |  merge_from(self, otherIndex, add_id)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  range_search_preassigned = replacement_range_search_preassigned(self, x, thresh, Iq, Dq, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_preassigned_c = range_search_preassigned(self, nx, x, radius, keys, coarse_dis, result, store_pairs=False, params=None, stats=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |      reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2
     |
     |  reconstruct_from_offset(self, list_no, offset, recons)
     |       Reconstruct a vector given the location in terms of (inv list index +
     |      inv list offset) instead of the id.
     |
     |      Useful for reconstructing when the direct_map is not maintained and
     |      the inv list offset is computed by search_preassigned() with
     |      `store_pairs` set.
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct a subset of the indexed vectors.
     |
     |      Overrides default implementation to bypass reconstruct() which requires
     |      direct_map to be maintained.
     |
     |      :type i0: int
     |      :param i0:     first vector to reconstruct
     |      :type ni: int
     |      :param ni:     nb of vectors to reconstruct
     |      :type recons: float
     |      :param recons: output array of reconstructed vectors, size ni * d
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Dataset manipulation functions
     |
     |  replace_invlists(self, il, own=False)
     |      replace the inverted lists, old one is deallocated if own_invlists
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |      sa_encode will call encode_vectors with include_listno=true
     |      :type n: int
     |      :param n:      nb of vectors to encode
     |      :type x: float
     |      :param x:      the vectors to encode
     |      :type bytes: uint8_t
     |      :param bytes:  output array for the codes
     |      :rtype: void
     |      :return: nb of bytes written to codes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      Overrides default implementation to avoid having to maintain direct_map
     |      and instead fetch the code offsets through the `store_pairs` flag in
     |      search_preassigned().
     |
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_and_return_codes = replacement_search_and_return_codes(self, x, k, *, include_listnos=False, params=None, D=None, I=None, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return the codes stored for these vectors
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      include_listnos : bool, optional
     |          whether to include the list ids in the first bytes of each code
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      codes : array_like, optional
     |          codes array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_return_codes_c = search_and_return_codes(self, n, x, k, distances, labels, recons, include_listno=False, params=None)
     |       Similar to search, but also returns the codes corresponding to the
     |      stored vectors for the search results.
     |
     |      :param codes:      codes (n, k, code_size)
     |      :type include_listno: boolean, optional
     |      :param include_listno:
     |                            include the list ids in the code (in this case add
     |                            ceil(log8(nlist)) to the code size)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      assign the vectors, then call search_preassign
     |
     |  search_preassigned = replacement_search_preassigned(self, x, k, Iq, Dq, *, params=None, D=None, I=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in an IVF index,
     |      with precalculated coarse quantization assignment.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      Dq : array_like, optional
     |          Distance array to the centroids, size (n, nprobe)
     |      Iq : array_like, optional
     |          Nearest centroids, size (n, nprobe)
     |
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_preassigned_c = search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None, stats=None)
     |
     |  set_direct_map_type(self, type)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the quantizer and calls train_encoder to train sub-quantizers
     |
     |  train_encoder_num_vectors(self)
     |      can be redefined by subclasses to indicate how many training vectors
     |      they need
     |
     |  update_vectors = replacement_update_vectors(self, keys, x) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  update_vectors_c = update_vectors(self, nv, idx, v)
     |       Update a subset of vectors.
     |
     |      The index must have a direct_map
     |
     |      :type nv: int
     |      :param nv:     nb of vectors to update
     |      :type idx: int
     |      :param idx:    vector indices to update, size nv
     |      :type v: float
     |      :param v:      vectors of new values, size nv*d
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from IndexIVF:
     |
     |  PARALLEL_MODE_NO_HEAP_INIT
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVF:
     |
     |  by_residual
     |      do the codes in the invlists encode the vectors relative to the
     |      centroids?
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  direct_map
     |      optional map that maps back ids to invlist entries. This
     |      enables reconstruct()
     |
     |  invlists
     |      Access to the actual data
     |
     |  own_invlists
     |
     |  parallel_mode
     |       Parallel mode determines how queries are parallelized with OpenMP
     |
     |      0 (default): split over queries
     |      1: parallelize over inverted lists
     |      2: parallelize over both
     |      3: split over queries with a finer granularity
     |
     |      PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
     |      prevent the heap to be initialized and finalized
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexIVFInterface:
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  nprobe
     |      number of probes at query time
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexIVFStats(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, other)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexIVFStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ndis
     |
     |  nheap_updates
     |
     |  nlist
     |
     |  nq
     |
     |  quantization_time
     |
     |  search_time
     |
     |  thisown
     |      The membership flag

    class IndexLSH(IndexFlatCodes)
     |  IndexLSH(*args)
     |
     |  The sign of each vector component is put in a binary signature
     |
     |  Method resolution order:
     |      IndexLSH
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  apply_preprocess(self, n, x)
     |       Preprocesses and resizes the input to the size required to
     |      binarize the data
     |
     |      :type x: float
     |      :param x: input vectors, size n * d
     |      :rtype: float
     |      :return: output vectors, size n * bits. May be the same pointer
     |                  as x, otherwise it should be deleted by the caller
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  transfer_thresholds(self, vt)
     |      transfer the thresholds to a pre-processing stage (and unset
     |      train_thresholds)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexLSH(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  nbits
     |      nb of bits per vector
     |
     |  rotate_data
     |      whether to apply a random rotation to input
     |
     |  rrot
     |      optional random rotation
     |
     |  thisown
     |      The membership flag
     |
     |  thresholds
     |      thresholds to compare with
     |
     |  train_thresholds
     |      whether we train thresholds or use 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexLattice(IndexFlatCodes)
     |  IndexLattice(d, nsq, scale_nbit, r2)
     |
     |  Index that encodes a vector with a series of Zn lattice quantizers
     |
     |  Method resolution order:
     |      IndexLattice
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, d, nsq, scale_nbit, r2)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexLattice(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  dsq
     |      dimension of sub-vectors
     |
     |  lattice_nbit
     |
     |  nsq
     |      number of sub-vectors
     |
     |  scale_nbit
     |      nb bits used to encode the scale, per subvector
     |
     |  thisown
     |      The membership flag
     |
     |  trained
     |      mins and maxes of the vector norms, per subquantizer
     |
     |  zn_sphere_codec
     |      the lattice quantizer
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search implemented by decoding (most index types will have a faster
     |      implementation)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexLocalSearchQuantizer(IndexAdditiveQuantizer)
     |  IndexLocalSearchQuantizer(*args)
     |
     |  Method resolution order:
     |      IndexLocalSearchQuantizer
     |      IndexAdditiveQuantizer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexLocalSearchQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lsq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatCodes
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatCodes
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizer:
     |
     |  aq
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexLocalSearchQuantizerFastScan(IndexAdditiveQuantizerFastScan)
     |  IndexLocalSearchQuantizerFastScan(*args)
     |
     |   Index based on a local search quantizer. Stored vectors are
     |  approximated by local search quantization codes.
     |  Can also be used as a codec
     |
     |  Method resolution order:
     |      IndexLocalSearchQuantizerFastScan
     |      IndexAdditiveQuantizerFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |      :type metric: int, optional
     |      :param metric:  metric type
     |      :type search_type: int, optional
     |      :param search_type: AQ search type
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexLocalSearchQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lsq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizerFastScan:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFastScan
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, *args)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFastScan
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFastScan
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors.
     |
     |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
     |             contiguous. But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from IndexFastScan
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNNDescent(Index)
     |  IndexNNDescent(*args)
     |
     |   The NNDescent index is a normal random-access index with an NNDescent
     |  link structure built on top
     |
     |  Method resolution order:
     |      IndexNNDescent
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNNDescent(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  nndescent
     |      Faiss results are 64-bit
     |
     |  own_fields
     |
     |  storage
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNNDescentFlat(IndexNNDescent)
     |  IndexNNDescentFlat(*args)
     |
     |  Flat index topped with with a NNDescent structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexNNDescentFlat
     |      IndexNNDescent
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNNDescentFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexNNDescent:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexNNDescent:
     |
     |  nndescent
     |      Faiss results are 64-bit
     |
     |  own_fields
     |
     |  storage
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNSG(Index)
     |  IndexNSG(*args)
     |
     |   The NSG index is a normal random-access index with a NSG
     |  link structure built on top
     |
     |  Method resolution order:
     |      IndexNSG
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
     |
     |  build_c = build(self, n, x, knn_graph, GK)
     |
     |  check_knn_graph(self, knn_graph, n, K)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNSG(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  GK
     |      K of KNN graph for building
     |
     |  build_type
     |      indicate how to build a knn graph
     |      - 0: build NSG with brute force search
     |      - 1: build NSG with NNDescent
     |
     |  is_built
     |      the index is built or not
     |
     |  nndescent_L
     |
     |  nndescent_R
     |
     |  nndescent_S
     |      parameters for nndescent
     |
     |  nndescent_iter
     |
     |  nsg
     |      the link structure
     |
     |  own_fields
     |      the sequential storage
     |
     |  storage
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNSGFlat(IndexNSG)
     |  IndexNSGFlat(*args)
     |
     |  Flat index topped with with a NSG structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexNSGFlat
     |      IndexNSG
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNSGFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexNSG:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
     |
     |  build_c = build(self, n, x, knn_graph, GK)
     |
     |  check_knn_graph(self, knn_graph, n, K)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexNSG:
     |
     |  GK
     |      K of KNN graph for building
     |
     |  build_type
     |      indicate how to build a knn graph
     |      - 0: build NSG with brute force search
     |      - 1: build NSG with NNDescent
     |
     |  is_built
     |      the index is built or not
     |
     |  nndescent_L
     |
     |  nndescent_R
     |
     |  nndescent_S
     |      parameters for nndescent
     |
     |  nndescent_iter
     |
     |  nsg
     |      the link structure
     |
     |  own_fields
     |      the sequential storage
     |
     |  storage
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNSGPQ(IndexNSG)
     |  IndexNSGPQ(*args)
     |
     |  PQ index topped with with a NSG structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexNSGPQ
     |      IndexNSG
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNSGPQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexNSG:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
     |
     |  build_c = build(self, n, x, knn_graph, GK)
     |
     |  check_knn_graph(self, knn_graph, n, K)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexNSG:
     |
     |  GK
     |      K of KNN graph for building
     |
     |  build_type
     |      indicate how to build a knn graph
     |      - 0: build NSG with brute force search
     |      - 1: build NSG with NNDescent
     |
     |  is_built
     |      the index is built or not
     |
     |  nndescent_L
     |
     |  nndescent_R
     |
     |  nndescent_S
     |      parameters for nndescent
     |
     |  nndescent_iter
     |
     |  nsg
     |      the link structure
     |
     |  own_fields
     |      the sequential storage
     |
     |  storage
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNSGSQ(IndexNSG)
     |  IndexNSGSQ(*args)
     |
     |  SQ index topped with with a NSG structure to access elements
     |  more efficiently.
     |
     |  Method resolution order:
     |      IndexNSGSQ
     |      IndexNSG
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNSGSQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexNSG:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  build = replacement_build(self, x, graph) from faiss.class_wrappers.handle_NSG.<locals>
     |
     |  build_c = build(self, n, x, knn_graph, GK)
     |
     |  check_knn_graph(self, knn_graph, n, K)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      entry point for search
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Trains the storage if needed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexNSG:
     |
     |  GK
     |      K of KNN graph for building
     |
     |  build_type
     |      indicate how to build a knn graph
     |      - 0: build NSG with brute force search
     |      - 1: build NSG with NNDescent
     |
     |  is_built
     |      the index is built or not
     |
     |  nndescent_L
     |
     |  nndescent_R
     |
     |  nndescent_S
     |      parameters for nndescent
     |
     |  nndescent_iter
     |
     |  nsg
     |      the link structure
     |
     |  own_fields
     |      the sequential storage
     |
     |  storage
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexNeuralNetCodec(IndexFlatCodes)
     |  IndexNeuralNetCodec(*args)
     |
     |  Method resolution order:
     |      IndexNeuralNetCodec
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, codes)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexNeuralNetCodec(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |
     |  nbits
     |
     |  net
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search implemented by decoding (most index types will have a faster
     |      implementation)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexPQ(IndexFlatCodes)
     |  IndexPQ(*args)
     |
     |   Index based on a product quantizer. Stored vectors are
     |  approximated by PQ codes.
     |
     |  Method resolution order:
     |      IndexPQ
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  hamming_distance_histogram(self, n, x, nb, xb, dist_histogram)
     |      prepare query for a polysemous search, but instead of
     |      computing the result, just get the histogram of Hamming
     |      distances. May be computed on a provided dataset if xb != NULL
     |      :type dist_histogram: int
     |      :param dist_histogram: (M * nbits + 1)
     |
     |  hamming_distance_table(self, n, x, dis)
     |       compute pairwise distances between queries and database
     |
     |      :type n: int
     |      :param n:    nb of query vectors
     |      :type x: float
     |      :param x:    query vector, size n * d
     |      :type dis: int
     |      :param dis:  output distances, size n * ntotal
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_core_polysemous(self, n, x, k, distances, labels, polysemous_ht, generalized_hamming)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexPQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  do_polysemous_training
     |      false = standard PQ
     |
     |  encode_signs
     |
     |  polysemous_ht
     |      Hamming threshold used for polysemy
     |
     |  polysemous_training
     |      parameters used for the polysemous training
     |
     |  pq
     |      The product quantizer used to encode the vectors
     |
     |  search_type
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  ST_HE = 1
     |
     |  ST_PQ = 0
     |
     |  ST_SDC = 3
     |
     |  ST_generalized_HE = 2
     |
     |  ST_polysemous = 4
     |
     |  ST_polysemous_generalize = 5
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexPQFastScan(IndexFastScan)
     |  IndexPQFastScan(*args)
     |
     |   Fast scan version of IndexPQ. Works for 4-bit PQ for now.
     |
     |  The codes are not stored sequentially but grouped in blocks of size bbs.
     |  This makes it possible to compute distances quickly with SIMD instructions.
     |
     |  Implementations:
     |  12: blocked loop with internal loop on Q with qbs
     |  13: same with reservoir accumulator to store results
     |  14: no qbs with heap accumulator
     |  15: no qbs with reservoir accumulator
     |
     |  Method resolution order:
     |      IndexPQFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |      build from an existing IndexPQ
     |
     |      |
     |
     |      *Overload 2:*
     |      build from an existing IndexPQ
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit PQ sub-quantizer nibbles)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexPQFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  pq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search for k nearest neighbors
     |
     |      :type n: int
     |      :param n:          number of query vectors
     |      :type x: float
     |      :param x:          query vectors (n * d)
     |      :type k: int
     |      :param k:          number of nearest neighbors to find
     |      :type distances: float
     |      :param distances:  output distances (n * k)
     |      :type labels: int
     |      :param labels:     output labels/indices (n * k)
     |      :type params: :py:class:`SearchParameters`, optional
     |      :param params:     optional search parameters
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexPQStats(builtins.object)
     |  statistics are robust to internal threading, but not if
     |  IndexPQ::search is called by multiple threads
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexPQStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n_hamming_pass
     |
     |  ncode
     |
     |  nq
     |
     |  thisown
     |      The membership flag

    class IndexPreTransform(Index)
     |  IndexPreTransform(*args)
     |
     |  Index that applies a LinearTransform transform on vectors before
     |  handing them over to a sub-index
     |
     |  Method resolution order:
     |      IndexPreTransform
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  apply_chain(self, n, x)
     |      apply the transforms in the chain. The returned float * may be
     |      equal to x, otherwise it should be deallocated.
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  prepend_transform = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      removes IDs from the index. Not supported by all indexes.
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  reverse_chain(self, n, xt, x)
     |      Reverse the transforms in the chain. May not be implemented for
     |      all transforms in the chain or may return approximate results.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexPreTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  chain
     |
     |  index
     |      chain of transforms
     |
     |  own_fields
     |      the sub-index
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexProductLocalSearchQuantizer(IndexAdditiveQuantizer)
     |  IndexProductLocalSearchQuantizer(*args)
     |
     |  Index based on a product local search quantizer.
     |
     |  Method resolution order:
     |      IndexProductLocalSearchQuantizer
     |      IndexAdditiveQuantizer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of local search quantizers
     |      :type Msub: int
     |      :param Msub:     number of subquantizers per LSQ
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits: number of local search quantizers
     |      :type Msub: int
     |      :param Msub: number of subquantizers per LSQ
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexProductLocalSearchQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  plsq
     |      The product local search quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatCodes
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatCodes
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizer:
     |
     |  aq
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexProductLocalSearchQuantizerFastScan(IndexAdditiveQuantizerFastScan)
     |  IndexProductLocalSearchQuantizerFastScan(*args)
     |
     |   Index based on a product local search quantizer. Stored vectors are
     |  approximated by product local search quantization codes.
     |  Can also be used as a codec
     |
     |  Method resolution order:
     |      IndexProductLocalSearchQuantizerFastScan
     |      IndexAdditiveQuantizerFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of local search quantizers
     |      :type Msub: int
     |      :param Msub:     number of subquantizers per LSQ
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |      :type metric: int, optional
     |      :param metric:  metric type
     |      :type search_type: int, optional
     |      :param search_type: AQ search type
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits: number of local search quantizers
     |      :type Msub: int
     |      :param Msub: number of subquantizers per LSQ
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexProductLocalSearchQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  plsq
     |      The product local search quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizerFastScan:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFastScan
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, *args)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFastScan
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFastScan
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors.
     |
     |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
     |             contiguous. But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from IndexFastScan
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexProductResidualQuantizer(IndexAdditiveQuantizer)
     |  IndexProductResidualQuantizer(*args)
     |
     |  Index based on a product residual quantizer.
     |
     |  Method resolution order:
     |      IndexProductResidualQuantizer
     |      IndexAdditiveQuantizer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of residual quantizers
     |      :type Msub: int
     |      :param Msub:      number of subquantizers per RQ
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits: number of residual quantizers
     |      :type Msub: int
     |      :param Msub: number of subquantizers per RQ
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexProductResidualQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  prq
     |      The product residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatCodes
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatCodes
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizer:
     |
     |  aq
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexProductResidualQuantizerFastScan(IndexAdditiveQuantizerFastScan)
     |  IndexProductResidualQuantizerFastScan(*args)
     |
     |   Index based on a product residual quantizer. Stored vectors are
     |  approximated by product residual quantization codes.
     |  Can also be used as a codec
     |
     |  Method resolution order:
     |      IndexProductResidualQuantizerFastScan
     |      IndexAdditiveQuantizerFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of residual quantizers
     |      :type Msub: int
     |      :param Msub:     number of subquantizers per RQ
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |      :type metric: int, optional
     |      :param metric:  metric type
     |      :type search_type: int, optional
     |      :param search_type: AQ search type
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits: number of residual quantizers
     |      :type Msub: int
     |      :param Msub: number of subquantizers per RQ
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexProductResidualQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  prq
     |      The product residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizerFastScan:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFastScan
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, *args)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFastScan
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFastScan
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors.
     |
     |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
     |             contiguous. But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from IndexFastScan
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexQINCo(IndexNeuralNetCodec)
     |  IndexQINCo(*args)
     |
     |  Method resolution order:
     |      IndexQINCo
     |      IndexNeuralNetCodec
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexQINCo(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  qinco
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexNeuralNetCodec:
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, codes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, codes)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexNeuralNetCodec:
     |
     |  M
     |
     |  nbits
     |
     |  net
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Search implemented by decoding (most index types will have a faster
     |      implementation)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRaBitQ(IndexFlatCodes)
     |  IndexRaBitQ(*args)
     |
     |  Method resolution order:
     |      IndexRaBitQ
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  get_quantized_distance_computer(self, qb_in, centered)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRaBitQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  center
     |
     |  centered
     |
     |  qb
     |
     |  rabitq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRaBitQFastScan(IndexFastScan)
     |  IndexRaBitQFastScan(*args)
     |
     |   Fast-scan version of RaBitQ index that processes 32 database vectors at a
     |  time using SIMD operations. Similar to IndexPQFastScan but adapted for
     |  RaBitQ's bit-level quantization with factors.
     |
     |  The key differences from IndexRaBitQ:
     |  - Processes vectors in batches of 32
     |  - Uses 4-bit groupings for SIMD optimization (4 dimensions per 4-bit unit)
     |  - Separates factors from quantized bits for efficient processing
     |  - Leverages existing PQ4 FastScan infrastructure where possible
     |
     |  Method resolution order:
     |      IndexRaBitQFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |      build from an existing IndexRaBitQ
     |
     |      |
     |
     |      *Overload 2:*
     |      build from an existing IndexRaBitQ
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  compute_per_vector_storage_size(self)
     |      Compute per-vector auxiliary data size in block aux region
     |
     |  fast_scan_code_size(self)
     |      Packed code size: (d + 7) / 8 bytes (1-bit-per-dimension sign bits,
     |      excluding factors)
     |
     |  get_CodePacker(self)
     |      Return CodePackerRaBitQ with enlarged block size
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Remove vectors and compact both PQ4 codes and auxiliary data
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRaBitQFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  center
     |      Center of all points (same as IndexRaBitQ)
     |
     |  centered
     |
     |  qb
     |      Default number of bits to quantize a query with
     |
     |  rabitq
     |      RaBitQ quantizer for encoding/decoding
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRandom(Index)
     |  IndexRandom(*args)
     |
     |   index that returns random results.
     |  used mainly for time benchmarks
     |
     |  Method resolution order:
     |      IndexRandom
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRandom(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  seed
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRefine(Index)
     |  IndexRefine(*args)
     |
     |  Index that queries in a base_index (a fast one) and refines the
     |  results with an exact search, hopefully improving the results.
     |
     |  Method resolution order:
     |      IndexRefine
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |      The sa_decode decodes from the index_refine, which is assumed to be more
     |      accurate
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRefine(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  base_index
     |      faster index to pre-select the vectors that should be filtered
     |
     |  k_factor
     |      factor between k requested in search and the k requested from
     |      the base_index (should be >= 1)
     |
     |  own_fields
     |      should the base index be deallocated?
     |
     |  own_refine_index
     |      same with the refinement index
     |
     |  refine_index
     |      refinement index
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRefineFlat(IndexRefine)
     |  IndexRefineFlat(*args)
     |
     |   Version where the refinement index is an IndexFlat. It has one additional
     |  constructor that takes a table of elements to add to the flat refinement
     |  index
     |
     |  Method resolution order:
     |      IndexRefineFlat
     |      IndexRefine
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRefineFlat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexRefine:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |      The sa_decode decodes from the index_refine, which is assumed to be more
     |      accurate
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexRefine:
     |
     |  base_index
     |      faster index to pre-select the vectors that should be filtered
     |
     |  k_factor
     |      factor between k requested in search and the k requested from
     |      the base_index (should be >= 1)
     |
     |  own_fields
     |      should the base index be deallocated?
     |
     |  own_refine_index
     |      same with the refinement index
     |
     |  refine_index
     |      refinement index
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRefinePanorama(IndexRefine)
     |  IndexRefinePanorama(*args)
     |
     |   Version where the search calls search_subset, allowing for Panorama
     |  refinement.
     |
     |  Method resolution order:
     |      IndexRefinePanorama
     |      IndexRefine
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init_multiple(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRefinePanorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexRefine:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |      The sa_decode decodes from the index_refine, which is assumed to be more
     |      accurate
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexRefine:
     |
     |  base_index
     |      faster index to pre-select the vectors that should be filtered
     |
     |  k_factor
     |      factor between k requested in search and the k requested from
     |      the base_index (should be >= 1)
     |
     |  own_fields
     |      should the base index be deallocated?
     |
     |  own_refine_index
     |      same with the refinement index
     |
     |  refine_index
     |      refinement index
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRefineSearchParameters(SearchParameters)
     |  IndexRefineSearchParameters(**args)
     |
     |  Method resolution order:
     |      IndexRefineSearchParameters
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRefineSearchParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  base_index_params
     |
     |  k_factor
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class IndexReplicas(ThreadedIndexBase)
     |  IndexReplicas(*args)
     |
     |  Takes individual faiss::Index instances, and splits queries for
     |  sending to each Index instance, and joins the results together
     |  when done.
     |  Each index is managed by a separate CPU thread.
     |
     |  Method resolution order:
     |      IndexReplicas
     |      ThreadedIndexBase
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |      The dimension that all sub-indices must share will be the dimension of
     |      the first sub-index added
     |      :type threaded: boolean, optional
     |      :param threaded: do we use one thread per sub-index or do queries
     |          sequentially?
     |
     |      |
     |
     |      *Overload 2:*
     |      :type d: int
     |      :param d: the dimension that all sub-indices must share
     |      :type threaded: boolean, optional
     |      :param threaded: do we use one thread per sub index or do queries
     |          sequentially?
     |
     |      |
     |
     |      *Overload 3:*
     |      :type d: int
     |      :param d: the dimension that all sub-indices must share
     |      :param threaded: do we use one thread per sub index or do queries
     |          sequentially?
     |
     |      |
     |
     |      *Overload 4:*
     |      int version due to the implicit bool conversion ambiguity of int as
     |      dimension
     |
     |      |
     |
     |      *Overload 5:*
     |      int version due to the implicit bool conversion ambiguity of int as
     |      dimension
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  addIndex = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
     |
     |  add_c = add(self, n, x)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  add_replica(self, index)
     |      Alias for addIndex()
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, arg2, v)
     |      reconstructs from the first index
     |
     |  remove_replica(self, index)
     |      Alias for removeIndex()
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |      faiss::Index API
     |      Query is partitioned into a slice for each sub-index
     |      split by ceil(n / #indices) for our sub-indices
     |
     |  syncWithSubIndexes(self)
     |      Synchronize the top-level index (IndexShards) with data in the
     |      sub-indices
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexReplicas(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ThreadedIndexBase:
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ThreadedIndexBase:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexResidualQuantizer(IndexAdditiveQuantizer)
     |  IndexResidualQuantizer(*args)
     |
     |   Index based on a residual quantizer. Stored vectors are
     |  approximated by residual quantization codes.
     |  Can also be used as a codec
     |
     |  Method resolution order:
     |      IndexResidualQuantizer
     |      IndexAdditiveQuantizer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexResidualQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  rq
     |      The residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFlatCodes
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids) from IndexFlatCodes
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm) from IndexFlatCodes
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from IndexFlatCodes
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFlatCodes
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from IndexFlatCodes
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFlatCodes
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizer:
     |
     |  aq
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexResidualQuantizerFastScan(IndexAdditiveQuantizerFastScan)
     |  IndexResidualQuantizerFastScan(*args)
     |
     |   Index based on a residual quantizer. Stored vectors are
     |  approximated by residual quantization codes.
     |  Can also be used as a codec
     |
     |  Method resolution order:
     |      IndexResidualQuantizerFastScan
     |      IndexAdditiveQuantizerFastScan
     |      IndexFastScan
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |      :type metric: int, optional
     |      :param metric:  metric type
     |      :type search_type: int, optional
     |      :param search_type: AQ search type
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexResidualQuantizerFastScan(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  rq
     |      The residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexAdditiveQuantizerFastScan:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexFastScan
     |       Add vectors to the index
     |
     |      :type n: int
     |      :param n:  number of vectors to add
     |      :type x: float
     |      :param x:  vectors to add (n * d)
     |
     |  compute_codes(self, codes, n, x)
     |       Compute codes for vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  output codes
     |      :type n: int
     |      :param n:      number of vectors to encode
     |      :type x: float
     |      :param x:      vectors to encode (n * d)
     |
     |  compute_float_LUT(self, lut, n, x, context)
     |       Compute floating-point lookup table for distance computation
     |
     |      :type lut: float
     |      :param lut:          output lookup table
     |      :type n: int
     |      :param n:            number of query vectors
     |      :type x: float
     |      :param x:            query vectors (n * d)
     |      :type context: :py:class:`FastScanDistancePostProcessing`
     |      :param context:      processing context containing all processors
     |
     |  estimate_norm_scale(self, n, x)
     |
     |  fast_scan_code_size(self)
     |      Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
     |
     |  init(self, *args)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons) from IndexFastScan
     |       Reconstruct a vector from its code
     |
     |      :type key: int
     |      :param key:     index of vector to reconstruct
     |      :type recons: float
     |      :param recons:  output reconstructed vector
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from IndexFastScan
     |       Remove vectors by ID selector
     |
     |      :type sel: :py:class:`IDSelector`
     |      :param sel:  selector defining which vectors to remove
     |      :rtype: int
     |      :return: number of vectors removed
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       Decode a set of vectors.
     |
     |       NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non-
     |             contiguous. But this method requires a contiguous representation.
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * code_size
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from IndexFastScan
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexAdditiveQuantizerFastScan:
     |
     |  aq
     |
     |  max_train_points
     |
     |  norm_scale
     |
     |  rescale_norm
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFastScan:
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       Check if another index is compatible for merging
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to check compatibility with
     |
     |  compute_quantized_LUT(self, n, x, lut, normalizers, context)
     |
     |  get_CodePacker(self)
     |       Get the code packer for this index
     |
     |      :rtype: :py:class:`CodePacker`
     |      :return: pointer to the code packer
     |
     |  get_block_stride(self)
     |       Get stride in bytes between consecutive SIMD blocks.
     |
     |      Derived from get_CodePacker()->block_size so that there is a
     |      single source of truth for the block layout.
     |
     |      :rtype: int
     |      :return: stride in bytes
     |
     |  init_fastscan(self, d, M, nbits, metric, bbs)
     |       Initialize the fast scan index
     |
     |      :type d: int
     |      :param d:         dimensionality of vectors
     |      :type M: int
     |      :param M:         number of subquantizers
     |      :type nbits: int
     |      :param nbits:     number of bits per subquantizer
     |      :type metric: int
     |      :param metric:    distance metric to use
     |      :type bbs: int
     |      :param bbs:       block size for SIMD processing
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       Merge another index into this one
     |
     |      :type otherIndex: :py:class:`Index`
     |      :param otherIndex:  index to merge from
     |      :type add_id: int, optional
     |      :param add_id:      ID offset to add to merged vectors
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      standalone codes interface (but the codes are flattened)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFastScan:
     |
     |  M
     |
     |  M2
     |
     |  bbs
     |
     |  code_size
     |
     |  codes
     |
     |  implem
     |
     |  ksub
     |
     |  nbits
     |
     |  ntotal2
     |
     |  orig_codes
     |
     |  qbs
     |
     |  skip
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRowwiseMinMax(IndexRowwiseMinMaxBase)
     |  IndexRowwiseMinMax(*args)
     |
     |  Stores scaling coefficients as fp32 values.
     |
     |  Method resolution order:
     |      IndexRowwiseMinMax
     |      IndexRowwiseMinMaxBase
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x) from IndexRowwiseMinMaxBase
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None) from IndexRowwiseMinMaxBase
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  train_inplace = replacement_train_inplace(self, x) from faiss.class_wrappers.handle_IndexRowwiseMinMax.<locals>
     |      Trains the index on a representative set of vectors inplace.
     |      The index must be trained before vectors can be added to it.
     |
     |      This call WILL change the values in the input array, because
     |      of two scaling procedures being performed inplace.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_inplace_c = train_inplace(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRowwiseMinMax(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexRowwiseMinMaxBase:
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexRowwiseMinMaxBase:
     |
     |  index
     |      sub-index
     |
     |  own_fields
     |      whether the subindex needs to be freed in the destructor.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRowwiseMinMaxBase(Index)
     |  IndexRowwiseMinMaxBase(*args, **kwargs)
     |
     |   Index wrapper that performs rowwise normalization to [0,1], preserving
     |   the coefficients. This is a vector codec index only.
     |
     |   Basically, this index performs a rowwise scaling to [0,1] of every row
     |   in an input dataset before calling subindex::train() and
     |   subindex::sa_encode(). sa_encode() call stores the scaling coefficients
     |    (scaler and minv) in the very beginning of every output code. The format:
     |       [scaler][minv][subindex::sa_encode() output]
     |   The de-scaling in sa_decode() is done using:
     |       output_rescaled = scaler * output + minv
     |
     |   An additional ::train_inplace() function is provided in order to do
     |   an inplace scaling before calling subindex::train() and, thus, avoiding
     |   the cloning of the input dataset, but modifying the input dataset because
     |   of the scaling and the scaling back. It is up to user to call
     |   this function instead of ::train()
     |
     |   Derived classes provide different data types for scaling coefficients.
     |   Currently, versions with fp16 and fp32 scaling coefficients are available.
     |  fp16 version adds 4 extra bytes per encoded vector
     |  fp32 version adds 8 extra bytes per encoded vector
     |   Provides base functions for rowwise normalizing indices.
     |
     |  Method resolution order:
     |      IndexRowwiseMinMaxBase
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train_inplace(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRowwiseMinMaxBase(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  index
     |      sub-index
     |
     |  own_fields
     |      whether the subindex needs to be freed in the destructor.
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexRowwiseMinMaxFP16(IndexRowwiseMinMaxBase)
     |  IndexRowwiseMinMaxFP16(*args)
     |
     |  Stores scaling coefficients as fp16 values.
     |
     |  Method resolution order:
     |      IndexRowwiseMinMaxFP16
     |      IndexRowwiseMinMaxBase
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  train_inplace = replacement_train_inplace(self, x) from faiss.class_wrappers.handle_IndexRowwiseMinMax.<locals>
     |      Trains the index on a representative set of vectors inplace.
     |      The index must be trained before vectors can be added to it.
     |
     |      This call WILL change the values in the input array, because
     |      of two scaling procedures being performed inplace.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_inplace_c = train_inplace(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexRowwiseMinMaxFP16(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexRowwiseMinMaxBase:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexRowwiseMinMaxBase:
     |
     |  index
     |      sub-index
     |
     |  own_fields
     |      whether the subindex needs to be freed in the destructor.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexScalarQuantizer(IndexFlatCodes)
     |  IndexScalarQuantizer(*args)
     |
     |  Flat index built on a scalar quantizer.
     |
     |  Method resolution order:
     |      IndexScalarQuantizer
     |      IndexFlatCodes
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type qtype: int
     |      :param qtype:  type of scalar quantizer (e.g., QT_4bit)
     |      :type metric: int, optional
     |      :param metric: distance metric used for search (default: METRIC_L2)
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  get_FlatCodesDistanceComputer(self)
     |       a FlatCodesDistanceComputer offers a distance_to_code method
     |
     |      The default implementation explicitly decodes the vector with sa_decode.
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexScalarQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  sq
     |      Used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexFlatCodes:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      default add uses sa_encode
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, x, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  get_CodePacker(self)
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  permute_entries = replacement_permute_entries(self, perm) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  permute_entries_c = permute_entries(self, perm)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       remove some ids. NB that because of the structure of the
     |      index, the semantics of this operation are
     |      different from the usual ones: the new ids are shifted
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexFlatCodes:
     |
     |  code_size
     |
     |  codes
     |      encoded dataset, size ntotal * code_size
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexShards(ThreadedIndexBase)
     |  IndexShards(*args)
     |
     |  Index that concatenates the results from several sub-indexes
     |
     |  Method resolution order:
     |      IndexShards
     |      ThreadedIndexBase
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |
     |      The dimension that all sub-indices must share will be the dimension of
     |      the first sub-index added
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :type successive_ids: boolean, optional
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 2:*
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :type successive_ids: boolean, optional
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 3:*
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 4:*
     |
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 5:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |      |
     |
     |      *Overload 6:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |      |
     |
     |      *Overload 7:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      supported only for sub-indices that implement add_with_ids
     |
     |  add_shard = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |      Cases (successive_ids, xids):
     |      - true, non-NULL       ERROR: it makes no sense to pass in ids and
     |                             request them to be shifted
     |      - true, NULL           OK: but should be called only once (calls add()
     |                             on sub-indexes).
     |      - false, non-NULL      OK: will call add_with_ids with passed in xids
     |                             distributed evenly over shards
     |      - false, NULL          OK: will call add_with_ids on each sub-index,
     |                             starting at ntotal
     |
     |  remove_shard(self, index)
     |      Alias for removeIndex()
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  syncWithSubIndexes(self)
     |      Synchronize the top-level index (IndexShards) with data in the
     |      sub-indices
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexShards(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  successive_ids
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ThreadedIndexBase:
     |
     |  addIndex(self, index)
     |      override an index that is managed by ourselves.
     |      WARNING: once an index is added, it becomes unsafe to touch it from any
     |      other thread than that on which is managing it, until we are shut
     |      down. Use runOnIndex to perform work on it instead.
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ThreadedIndexBase:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class IndexShardsIVF(IndexShards, Level1Quantizer)
     |  IndexShardsIVF(quantizer, nlist, threaded=False, successive_ids=True)
     |
     |  IndexShards with a common coarse quantizer. All the indexes added should be
     |  IndexIVFInterface indexes so that the search_precomputed can be called.
     |
     |  Method resolution order:
     |      IndexShardsIVF
     |      IndexShards
     |      ThreadedIndexBase
     |      Index
     |      Level1Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, quantizer, nlist, threaded=False, successive_ids=True)
     |      *Overload 1:*
     |
     |      The dimension that all sub-indices must share will be the dimension of
     |      the first sub-index added
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :type successive_ids: boolean, optional
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 2:*
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :type successive_ids: boolean, optional
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 3:*
     |
     |      :type threaded: boolean, optional
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 4:*
     |
     |      :param threaded:     do we use one thread per sub_index or do
     |                              queries sequentially?
     |      :param successive_ids: should we shift the returned ids by
     |                              the size of each sub-index or return them
     |                              as they are?
     |
     |      |
     |
     |      *Overload 5:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |      |
     |
     |      *Overload 6:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |      |
     |
     |      *Overload 7:*
     |       int version due to the implicit bool conversion ambiguity of int as
     |       dimension
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  addIndex(self, index)
     |      override an index that is managed by ourselves.
     |      WARNING: once an index is added, it becomes unsafe to touch it from any
     |      other thread than that on which is managing it, until we are shut
     |      down. Use runOnIndex to perform work on it instead.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexShardsIVF(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexShards:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      supported only for sub-indices that implement add_with_ids
     |
     |  add_shard = replacement_method(self, *args) from faiss.add_ref_in_method.<locals>
     |
     |  remove_shard(self, index)
     |      Alias for removeIndex()
     |
     |  syncWithSubIndexes(self)
     |      Synchronize the top-level index (IndexShards) with data in the
     |      sub-indices
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexShards:
     |
     |  successive_ids
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ThreadedIndexBase:
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ThreadedIndexBase:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Level1Quantizer:
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Level1Quantizer:
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer

    class IndexSplitVectors(Index)
     |  IndexSplitVectors(d, threaded=False)
     |
     |   splits input vectors in segments and assigns each segment to a sub-index
     |  used to distribute a MultiIndexQuantizer
     |
     |  Method resolution order:
     |      IndexSplitVectors
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, d, threaded=False)
     |      sum of dimensions seen so far
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |
     |  add_sub_index(self, arg2)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  sync_with_sub_indexes(self)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IndexSplitVectors(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  own_fields
     |
     |  sub_indexes
     |
     |  sum_d
     |
     |  thisown
     |      The membership flag
     |
     |  threaded
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class Int16Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int16Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Int32Tensor2D(builtins.object)
     |  Int32Tensor2D(*args)
     |
     |  Implements a few neural net layers, mainly to support QINCo
     |
     |  Methods defined here:
     |
     |  __iadd__(self, arg2)
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Tensor2D.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  column(self, j)
     |      get column #j as a 1-column Tensor2D
     |
     |  data(self, *args)
     |
     |  numel(self)
     |
     |  numpy(self) from faiss.class_wrappers.handle_Tensor2D.<locals>
     |
     |  original_init = __init__(self, n0, n1, data=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int32Tensor2D(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  shape
     |
     |  thisown
     |      The membership flag
     |
     |  v

    class Int32Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Int32VectorVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int32VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Int64Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int64Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Int64VectorVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int64VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Int8Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Int8Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class InterruptCallback(builtins.object)
     |  InterruptCallback(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  want_interrupt(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InterruptCallback(...)
     |
     |  check()
     |       check if:
     |      - an interrupt callback is set
     |      - the callback returns true
     |      if this is the case, then throw an exception. Should not be called
     |      from multiple threads.
     |
     |  clear_instance()
     |
     |  get_period_hint(flops)
     |       assuming each iteration takes a certain number of flops, what
     |      is a reasonable interval to check for interrupts?
     |
     |  is_interrupted()
     |      same as check() but return true if is interrupted instead of
     |      throwing. Can be called from multiple threads.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class IntersectionCriterion(AutoTuneCriterion)
     |  IntersectionCriterion(nq, R)
     |
     |  Method resolution order:
     |      IntersectionCriterion
     |      AutoTuneCriterion
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, nq, R)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  evaluate(self, D, I)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_IntersectionCriterion(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  R
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AutoTuneCriterion:
     |
     |  evaluate_c = evaluate(self, D, I)
     |       Evaluate the criterion.
     |
     |      :type D: float
     |      :param D:  size nq * nnn
     |      :type I: int
     |      :param I:  size nq * nnn
     |      :rtype: float
     |      :return: the criterion, between 0 and 1. Larger is better.
     |
     |  set_groundtruth = replacement_set_groundtruth(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
     |
     |  set_groundtruth_c = set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
     |       Initializes the gt_D and gt_I vectors. Must be called before evaluating
     |
     |      :type gt_D_in: float
     |      :param gt_D_in:  size nq * gt_nnn
     |      :type gt_I_in: int
     |      :param gt_I_in:  size nq * gt_nnn
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AutoTuneCriterion:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  gt_D
     |      Ground-truth distances (size nq * gt_nnn)
     |
     |  gt_I
     |      Ground-truth indexes (size nq * gt_nnn)
     |
     |  gt_nnn
     |      nb of GT NNs required to evaluate criterion
     |
     |  nnn
     |      nb of NNs that the query should request
     |
     |  nq
     |      nb of queries this criterion is evaluated on

    class InvertedListScanner(builtins.object)
     |  InvertedListScanner(*args, **kwargs)
     |
     |   Object that handles a query. The inverted lists to scan are
     |  provided externally. The object has a lot of state, but
     |  distance_to_code and scan_codes can be called in multiple
     |  threads
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  distance_to_code(self, code)
     |      compute a single query-to-code distance
     |
     |  iterate_codes(self, iterator, distances, labels, k, list_size)
     |
     |  iterate_codes_range(self, iterator, radius, result, list_size)
     |
     |  scan_codes(self, *args)
     |       scan a set of codes, compute distances to current query, and
     |      update heap of results if necessary. Default implementation
     |      calls distance_to_code.
     |
     |      :type n: int
     |      :param n:          number of codes to scan
     |      :type codes: uint8_t
     |      :param codes:      codes to scan (n * code_size)
     |      :type ids: int
     |      :param ids:        corresponding ids (ignored if store_pairs)
     |      :type distances: float
     |      :param distances:  heap distances (size k)
     |      :type labels: int
     |      :param labels:     heap labels (size k)
     |      :type k: int
     |      :param k:          heap size
     |      :rtype: int
     |      :return: number of heap updates performed
     |
     |  scan_codes_range(self, n, codes, ids, radius, result)
     |       scan a set of codes, compute distances to current query and
     |      update results if distances are below radius
     |
     |      (default implementation fails)
     |
     |  set_list(self, list_no, coarse_dis)
     |      following codes come from this inverted list
     |
     |  set_query(self, query_vector)
     |      from now on we handle this query.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InvertedListScanner(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      used in default implementation of scan_codes
     |
     |  keep_max
     |      keep maximum instead of minimum
     |
     |  list_no
     |      remember current list
     |
     |  sel
     |      search in this subset of ids
     |
     |  store_pairs
     |      store positions in invlists rather than labels
     |
     |  thisown
     |      The membership flag

    class InvertedListScannerStats(builtins.object)
     |  Per-list statistics returned by inverted-list scanners.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InvertedListScannerStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  nheap_updates
     |      Number of heap updates.
     |
     |  scan_cnt
     |      Number of distances computed after IDSelector filtering.
     |
     |  thisown
     |      The membership flag

    class InvertedLists(builtins.object)
     |  InvertedLists(*args, **kwargs)
     |
     |   Table of inverted lists
     |  multithreading rules:
     |  - concurrent read accesses are allowed
     |  - concurrent update accesses are allowed
     |  - for resize and add_entries, only concurrent access to different lists
     |    are allowed
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  reset(self)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  thisown
     |      The membership flag
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class InvertedListsIOHook(builtins.object)
     |  InvertedListsIOHook(*args, **kwargs)
     |
     |   Callbacks to handle other types of InvertedList objects.
     |
     |  The callbacks should be registered with add_callback before calling
     |  read_index or read_InvertedLists. The callbacks for
     |  OnDiskInvertedLists are registrered by default. The invlist type is
     |  identified by:
     |
     |  - the key (a fourcc) at read time
     |  - the class name (as given by typeid.name) at write time
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  read(self, f, io_flags)
     |      called when the fourcc matches this class's fourcc
     |
     |  read_ArrayInvertedLists(self, f, io_flags, nlist, code_size, sizes)
     |       read from a ArrayInvertedLists into this invertedlist type.
     |      For this to work, the callback has to be enabled and the io_flag has to
     |      be set to IO_FLAG_SKIP_IVF_DATA | (16 upper bits of the fourcc)
     |
     |      (default implementation fails)
     |
     |  write(self, ils, f)
     |      write the index to the IOWriter (including the fourcc)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InvertedListsIOHook(...)
     |
     |  add_callback(arg1)
     |
     |  lookup(h)
     |
     |  lookup_classname(classname)
     |
     |  print_callbacks()
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  classname
     |      typeid.name
     |
     |  key
     |      string version of the fourcc
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class InvertedListsIterator(builtins.object)
     |  InvertedListsIterator(*args, **kwargs)
     |
     |  Definition of inverted lists + a few common classes that implement
     |  the interface.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get_id_and_codes(self)
     |
     |  is_available(self)
     |
     |  next(self)
     |
     |  on_distance_computed(self, arg2, arg3)
     |      Called from iterate_codes after distance computation for the vector
     |      returned by the most recent get_id_and_codes(). Default: no-op.
     |      Only invoked when has_search_callbacks_ is true.
     |
     |  on_heap_changed(self, arg2, arg3)
     |      Called from iterate_codes when a vector replaces the current worst
     |      in the top-K heap. evicted_id is the displaced entry. Default: no-op.
     |      Only invoked when has_search_callbacks_ is true.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InvertedListsIterator(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  has_search_callbacks_
     |      When true, iterate_codes will invoke on_distance_computed() and
     |      on_heap_changed() via virtual dispatch. When false (the default),
     |      iterate_codes skips the callbacks entirely — the guard branch is
     |      perfectly predicted and costs ~0 cycles, so non-callback users
     |      pay no overhead. Derived classes that override the callbacks
     |      should set this to true in their constructor.
     |
     |  thisown
     |      The membership flag

    class InvertedListsPtrVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_InvertedListsPtrVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class LSQTimer(builtins.object)
     |  A helper struct to count consuming time during training.
     |  It is NOT thread-safe.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, name, delta)
     |
     |  get(self, name)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_LSQTimer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  t
     |
     |  thisown
     |      The membership flag

    class LSQTimerScope(builtins.object)
     |  LSQTimerScope(timer, name)
     |
     |  Methods defined here:
     |
     |  __init__(self, timer, name)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  finish(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_LSQTimerScope(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  finished
     |
     |  name
     |
     |  t0
     |
     |  thisown
     |      The membership flag
     |
     |  timer

    class Level1Quantizer(builtins.object)
     |  Level1Quantizer(*args)
     |
     |   Encapsulates a quantizer object for the IndexIVF
     |
     |  The class isolates the fields that are independent of the storage
     |  of the lists (especially training)
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.add_ref_in_constructor.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  coarse_code_size(self)
     |      compute the number of bytes required to store list ids
     |
     |  decode_listno(self, code)
     |
     |  encode_listno(self, list_no, code)
     |
     |  train_q1(self, n, x, verbose, metric_type)
     |      Trains the quantizer and calls train_residual to train sub-quantizers
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Level1Quantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  clustering_index
     |      to override index used during clustering
     |
     |  cp
     |      to override default clustering params
     |
     |  nlist
     |      number of inverted lists
     |
     |  own_fields
     |      whether object owns the quantizer
     |
     |  quantizer
     |      quantizer that maps vectors to inverted lists
     |
     |  quantizer_trains_alone
     |      = 0: use the quantizer as index in a kmeans training
     |      = 1: just pass on the training set to the train() of the quantizer
     |      = 2: kmeans training on a flat index + add the centroids to the quantizer
     |
     |  thisown
     |      The membership flag

    class Linear(builtins.object)
     |  Linear(*args)
     |
     |  minimal translation of nn.Linear
     |
     |  Methods defined here:
     |
     |  __call__(self, x)
     |      Call self as a function.
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Linear.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  from_array(self, array, bias=None) from faiss.class_wrappers.handle_Linear.<locals>
     |      copy weights from numpy array
     |
     |  from_torch(self, linear) from faiss.class_wrappers.handle_Linear.<locals>
     |      copy weights from torch.Linear
     |
     |  original_init = __init__(self, in_features, out_features, bias=True)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Linear(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  bias
     |
     |  in_features
     |
     |  out_features
     |
     |  thisown
     |      The membership flag
     |
     |  weight

    class LinearTransform(VectorTransform)
     |  LinearTransform(din=0, dout=0, have_bias_in=False)
     |
     |   Generic linear transformation, with bias term applied on output
     |  y = A * x + b
     |
     |  Method resolution order:
     |      LinearTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, din=0, dout=0, have_bias_in=False)
     |      both d_in > d_out and d_out < d_in are supported
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |      same as apply, but result is pre-allocated
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  print_if_verbose(self, name, mat, n, d)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      works only if is_orthonormal
     |
     |  set_is_orthonormal(self)
     |      compute A^T * A to set the is_orthonormal flag
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x) from VectorTransform
     |       Perform training on a representative set of vectors. Does
     |      nothing by default.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  transform_transpose(self, n, y, x)
     |      compute x = A^T * (x - b)
     |      is reverse transform if A has orthonormal lines
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_LinearTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  A
     |      Transformation matrix, size d_out * d_in
     |
     |  b
     |      bias vector, size d_out
     |
     |  have_bias
     |
     |  is_orthonormal
     |      whether to use the bias term
     |       check if matrix A is orthonormal (enables reverse_transform)
     |
     |  thisown
     |      The membership flag
     |
     |  verbose
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class LocalSearchCoarseQuantizer(AdditiveCoarseQuantizer)
     |  LocalSearchCoarseQuantizer(*args)
     |
     |  Method resolution order:
     |      LocalSearchCoarseQuantizer
     |      AdditiveCoarseQuantizer
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_LocalSearchCoarseQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  lsq
     |      The residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveCoarseQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      N/A
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids) from Index
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from Index
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1) from Index
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from Index
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons) from Index
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from Index
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from Index
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  reset(self)
     |      N/A
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from Index
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from Index
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None) from Index
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveCoarseQuantizer:
     |
     |  aq
     |
     |  centroid_norms
     |      norms of centroids, useful for knn-search
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class LocalSearchQuantizer(AdditiveQuantizer)
     |  LocalSearchQuantizer(*args)
     |
     |   Implementation of LSQ/LSQ++ described in the following two papers:
     |
     |  Revisiting additive quantization
     |  Julieta Martinez, et al. ECCV 2016
     |
     |  LSQ++: Lower running time and higher recall in multi-codebook quantization
     |  Julieta Martinez, et al. ECCV 2018
     |
     |  This implementation is mostly translated from the Julia implementations
     |  by Julieta Martinez:
     |  (https://github.com/una-dinosauria/local-search-quantization,
     |   https://github.com/una-dinosauria/Rayuela.jl)
     |
     |  The trained codes are stored in `codebooks` which is called
     |  `centroids` in PQ and RQ.
     |
     |  Method resolution order:
     |      LocalSearchQuantizer
     |      AdditiveQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_binary_terms(self, binaries)
     |       Compute binary terms
     |
     |      :type binaries: float
     |      :param binaries: binary terms, size M * M * K * K
     |
     |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |      :type n: int
     |      :param n:      number of vectors
     |      :type centroids: float, optional
     |      :param centroids:  centroids to be added to x, size n * d
     |
     |  compute_unary_terms(self, x, unaries, n)
     |       Compute unary terms
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       vectors to encode, size n * d
     |      :type unaries: float
     |      :param unaries: unary terms, size n * M * K
     |
     |  evaluate(self, codes, x, n, objs=None)
     |       Helper function to compute reconstruction error
     |
     |      :type codes: int
     |      :param codes: encoded codes, size n * M
     |      :type x: float
     |      :param x:     vectors to encode, size n * d
     |      :type n: int
     |      :param n:     number of vectors
     |      :type objs: float, optional
     |      :param objs:  if it is not null, store reconstruction
     |                              error of each vector into it, size n
     |
     |  icm_encode(self, codes, x, n, ils_iters, gen)
     |       Encode vectors given codebooks using iterative conditional mode (icm).
     |
     |      :type codes: int
     |      :param codes:     output codes, size n * M
     |      :type x: float
     |      :param x:         vectors to encode, size n * d
     |      :type n: int
     |      :param n:         number of vectors
     |      :type ils_iters: int
     |      :param ils_iters: number of iterations of iterative local search
     |
     |  icm_encode_impl(self, codes, x, unaries, gen, n, ils_iters, verbose)
     |
     |  icm_encode_step(self, codes, unaries, binaries, n, n_iters)
     |
     |  perturb_codebooks(self, T, stddev, gen)
     |       Add some perturbation to codebooks
     |
     |      :type T: float
     |      :param T:         temperature of simulated annealing
     |      :type stddev: std::vector< float >
     |      :param stddev:    standard deviations of each dimension in training data
     |
     |  perturb_codes(self, codes, n, gen)
     |       Add some perturbation to codes
     |
     |      :type codes: int
     |      :param codes: codes to be perturbed, size n * M
     |      :type n: int
     |      :param n:     number of vectors
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  update_codebooks(self, x, codes, n)
     |       Update codebooks given encodings
     |
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |      :type codes: int
     |      :param codes:  encoded training vectors, size n * M
     |      :type n: int
     |      :param n:      number of vectors
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_LocalSearchQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  K
     |      number of codes per codebook
     |
     |  chunk_size
     |      nb of vectors to encode at a time
     |
     |  encode_ils_iters
     |      iterations of local search in encoding
     |
     |  icm_encoder_factory
     |
     |  icm_iters
     |      number of iterations in icm
     |
     |  lambd
     |      regularization factor
     |
     |  nperts
     |      number of perturbation in each code
     |      if non-NULL, use this encoder to encode (owned by the object)
     |
     |  p
     |      temperature factor
     |
     |  random_seed
     |      seed for random generator
     |
     |  thisown
     |      The membership flag
     |
     |  train_ils_iters
     |      iterations of local search in training
     |
     |  train_iters
     |      number of iterations in training
     |
     |  update_codebooks_with_double
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveQuantizer:
     |
     |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
     |       Compute inner-product look-up tables. Used in the centroid search
     |      functions.
     |
     |      :type xq: float
     |      :param xq:     query vector, size (n, d)
     |      :type LUT: float
     |      :param LUT:    look-up table, size (n, total_codebook_size)
     |      :type alpha: float, optional
     |      :param alpha:  compute alpha * inner-product
     |      :type ld_lut: int, optional
     |      :param ld_lut:  leading dimension of LUT
     |
     |  compute_centroid_norms(self, norms)
     |       For L2 search we need the L2 norms of the centroids
     |
     |      :type norms: float
     |      :param norms:    output norms table, size total_codebook_size
     |
     |  compute_codebook_tables(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_64bit(self, n, x)
     |      decoding function for a code in a 64-bit word
     |
     |  decode_c = decode(self, codes, x, n)
     |       Decode a set of vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  decode_qcint(self, c)
     |      decode norm by non-uniform scalar quantization
     |
     |  decode_unpacked(self, codes, x, n, ld_codes=-1)
     |       Decode a set of vectors in non-packed format
     |
     |      :type codes: int
     |      :param codes:  codes to decode, size n * ld_codes
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  encode_norm(self, norm)
     |      encode a norm into norm_bits bits
     |
     |  encode_qcint(self, x)
     |      encode norm by non-uniform scalar quantization
     |
     |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
     |      Exact L2 search, with precomputed norms
     |
     |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
     |      exact IP search
     |
     |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
     |       pack a series of code to bit-compact format
     |
     |      :type codes: int
     |      :param codes:        codes to be packed, size n * code_size
     |      :type packed_codes: uint8_t
     |      :param packed_codes: output bit-compact codes
     |      :type ld_codes: int, optional
     |      :param ld_codes:     leading dimension of codes
     |      :type norms: float, optional
     |      :param norms:        norms of the vectors (size n). Will be computed if
     |                              needed but not provided
     |      :type centroids: float, optional
     |      :param centroids:    centroids to be added to x, size n * d
     |
     |  set_derived_values(self)
     |      Train the norm quantizer
     |
     |  train_norm(self, n, norms)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveQuantizer:
     |
     |  M
     |      number of codebooks
     |
     |  centroid_norms
     |      norms of all codebook entries (size total_codebook_size)
     |
     |  codebook_cross_products
     |      dot products of all codebook entries with the previous codebooks
     |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
     |
     |  codebook_offsets
     |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
     |      in the codebooks table of size total_codebook_size by d
     |
     |  codebooks
     |      codebooks
     |
     |  is_trained
     |      is trained or not
     |
     |  max_mem_distances
     |      norms and distance matrixes with beam search can get large, so use this
     |      to control for the amount of memory that can be allocated
     |
     |  nbits
     |      bits for each step
     |
     |  norm_bits
     |      bits allocated for the norms
     |
     |  norm_max
     |
     |  norm_min
     |      min/max for quantization of norms
     |
     |  norm_tabs
     |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
     |      store norms of codebook entries for 4-bit fastscan
     |
     |  only_8bit
     |      are all nbits = 8 (use faster decoder)
     |
     |  qnorm
     |      store and search norms
     |
     |  search_type
     |      Also determines what's in the codes
     |
     |  tot_bits
     |      total number of bits (indexes + norms)
     |
     |  total_codebook_size
     |      size of the codebook in vectors
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AdditiveQuantizer:
     |
     |  ST_LUT_nonorm = 1
     |
     |  ST_count = 10
     |
     |  ST_decompress = 0
     |
     |  ST_norm_cqint4 = 7
     |
     |  ST_norm_cqint8 = 6
     |
     |  ST_norm_float = 3
     |
     |  ST_norm_from_LUT = 2
     |
     |  ST_norm_lsq2x4 = 8
     |
     |  ST_norm_qint4 = 5
     |
     |  ST_norm_qint8 = 4
     |
     |  ST_norm_rq2x4 = 9
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class MapLong2Long(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add = replacement_map_add(self, keys, vals) from faiss.class_wrappers.handle_MapLong2Long.<locals>
     |
     |  add_c = add(self, n, keys, vals)
     |
     |  search(self, key)
     |
     |  search_multiple = replacement_map_search_multiple(self, keys) from faiss.class_wrappers.handle_MapLong2Long.<locals>
     |
     |  search_multiple_c = search_multiple(self, n, keys, vals)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MapLong2Long(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  map
     |
     |  thisown
     |      The membership flag

    class MappedFileIOReader(IOReader)
     |  MappedFileIOReader(owner)
     |
     |  Method resolution order:
     |      MappedFileIOReader
     |      IOReader
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, owner)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  filedescriptor(self)
     |
     |  mmap(self, ptr, size, nitems)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MappedFileIOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  mmap_owner
     |
     |  pos
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOReader:
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOReader:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class MaskedInvertedLists(ReadOnlyInvertedLists)
     |  MaskedInvertedLists(il0_in, il1_in)
     |
     |   use the first inverted lists if they are non-empty otherwise use the second
     |
     |  This is useful if il1 has a few inverted lists that are too long,
     |  and that il0 has replacement lists for those, with empty lists for
     |  the others.
     |
     |  Method resolution order:
     |      MaskedInvertedLists
     |      ReadOnlyInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, il0_in, il1_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaskedInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  il0
     |
     |  il1
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ReadOnlyInvertedLists:
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class MatrixStats(builtins.object)
     |  MatrixStats(m)
     |
     |   Reports some statistics on a dataset and comments on them.
     |
     |  It is a class rather than a function so that all stats can also be
     |  accessed from code
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, m) from faiss.class_wrappers.handle_MatrixStats.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  do_comment(self, fmt)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MatrixStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  buf
     |
     |  comments
     |
     |  d
     |
     |  hash_value
     |
     |  max_norm2
     |
     |  min_norm2
     |
     |  n
     |
     |  n0
     |
     |  n_collision
     |
     |  n_valid
     |
     |  nbuf
     |
     |  occurrences
     |
     |  per_dim_stats
     |
     |  thisown
     |      The membership flag

    class MaybeOwnedVectorFloat32(builtins.object)
     |  MaybeOwnedVectorFloat32(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, *args)
     |
     |  begin(self, *args)
     |
     |  byte_size(self)
     |
     |  clear(self)
     |
     |  data(self, *args)
     |
     |  end(self, *args)
     |
     |  erase(self, begin, end)
     |
     |  resize(self, *args)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorFloat32(...)
     |
     |  create_view(address, n_elements, owner)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  c_ptr
     |
     |  c_size
     |
     |  is_owned
     |
     |  owned_data
     |
     |  owner
     |
     |  thisown
     |      The membership flag
     |
     |  view_data
     |
     |  view_size

    class MaybeOwnedVectorFloat32Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorFloat32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class MaybeOwnedVectorInt32(builtins.object)
     |  MaybeOwnedVectorInt32(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, *args)
     |
     |  begin(self, *args)
     |
     |  byte_size(self)
     |
     |  clear(self)
     |
     |  data(self, *args)
     |
     |  end(self, *args)
     |
     |  erase(self, begin, end)
     |
     |  resize(self, *args)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorInt32(...)
     |
     |  create_view(address, n_elements, owner)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  c_ptr
     |
     |  c_size
     |
     |  is_owned
     |
     |  owned_data
     |
     |  owner
     |
     |  thisown
     |      The membership flag
     |
     |  view_data
     |
     |  view_size

    class MaybeOwnedVectorInt32Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorInt32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class MaybeOwnedVectorOwner(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorOwner(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class MaybeOwnedVectorUInt8(builtins.object)
     |  MaybeOwnedVectorUInt8(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, *args)
     |
     |  begin(self, *args)
     |
     |  byte_size(self)
     |
     |  clear(self)
     |
     |  data(self, *args)
     |
     |  end(self, *args)
     |
     |  erase(self, begin, end)
     |
     |  resize(self, *args)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorUInt8(...)
     |
     |  create_view(address, n_elements, owner)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  c_ptr
     |
     |  c_size
     |
     |  is_owned
     |
     |  owned_data
     |
     |  owner
     |
     |  thisown
     |      The membership flag
     |
     |  view_data
     |
     |  view_size

    class MaybeOwnedVectorUInt8Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MaybeOwnedVectorUInt8Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class MmappedFileMappingOwner(MaybeOwnedVectorOwner)
     |  MmappedFileMappingOwner(*args)
     |
     |  Method resolution order:
     |      MmappedFileMappingOwner
     |      MaybeOwnedVectorOwner
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  data(self)
     |
     |  size(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MmappedFileMappingOwner(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaybeOwnedVectorOwner:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class MultiIndexQuantizer(Index)
     |  MultiIndexQuantizer(*args)
     |
     |  Quantizer where centroids are virtual: they are the Cartesian
     |  product of sub-centroids.
     |
     |  Method resolution order:
     |      MultiIndexQuantizer
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       number of bit per subvector index
     |      :type d: int
     |      :param d: dimension of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      add and reset will crash at runtime
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MultiIndexQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  pq
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class MultiIndexQuantizer2(MultiIndexQuantizer)
     |  MultiIndexQuantizer2(*args)
     |
     |  MultiIndexQuantizer where the PQ assignment is performed by sub-indexes
     |
     |  Method resolution order:
     |      MultiIndexQuantizer2
     |      MultiIndexQuantizer
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       number of bit per subvector index
     |      :type d: int
     |      :param d: dimension of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_MultiIndexQuantizer2(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  assign_indexes
     |      M Indexes on d / M dimensions
     |
     |  own_fields
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MultiIndexQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      add and reset will crash at runtime
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reset(self)
     |      removes all elements from the database.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MultiIndexQuantizer:
     |
     |  pq
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class NNDescent(builtins.object)
     |  NNDescent(d, K)
     |
     |  Methods defined here:
     |
     |  __init__(self, d, K)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  build(self, qdis, n, verbose)
     |
     |  eval_recall(self, ctrl_points, acc_eval_set)
     |      Evaluate the quality of KNNG built
     |
     |  generate_eval_set(self, qdis, c, v, N)
     |      Sample a small number of points to evaluate the quality of KNNG built
     |
     |  init_graph(self, qdis)
     |      Initialize the KNN graph randomly
     |
     |  join(self, qdis)
     |      Perform local join on each node
     |
     |  nndescent(self, qdis, verbose)
     |      Perform NNDescent algorithm
     |
     |  reset(self)
     |
     |  search(self, qdis, topk, indices, dists, vt)
     |
     |  update(self)
     |      Sample new neighbors for each node to perform local join later
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_NNDescent(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  K
     |
     |  L
     |
     |  R
     |
     |  S
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |
     |  final_graph
     |
     |  graph
     |
     |  has_built
     |
     |  iter
     |
     |  ntotal
     |
     |  random_seed
     |
     |  search_L
     |
     |  thisown
     |      The membership flag

    class NSG(builtins.object)
     |  NSG(R=32)
     |
     |  Methods defined here:
     |
     |  __init__(self, R=32)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_reverse_links(self, q, locks, dis, graph)
     |
     |  attach_unlinked(self, storage, vt, vt2, degrees)
     |
     |  build(self, storage, n, knn_graph, verbose)
     |
     |  check_graph(self)
     |
     |  dfs(self, vt, root, cnt)
     |
     |  get_final_graph(self)
     |
     |  init_graph(self, storage, knn_graph)
     |
     |  link(self, storage, knn_graph, graph, verbose)
     |
     |  reset(self)
     |
     |  search(self, dis, k, I, D, vt)
     |
     |  sync_prune(self, q, pool, dis, vt, knn_graph, graph)
     |
     |  tree_grow(self, storage, degrees)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_NSG(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  C
     |      candidate pool size at construction time
     |
     |  L
     |      length of the search path at construction time
     |
     |  R
     |      nb of neighbors per node
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  enterpoint
     |      enterpoint
     |
     |  final_graph
     |      NSG graph structure
     |
     |  is_built
     |      NSG is built or not
     |
     |  ntotal
     |      nb of nodes
     |
     |  rng
     |      random generator
     |
     |  search_L
     |      length of the search path
     |
     |  thisown
     |      The membership flag
     |
     |  use_visited_hashset

    class NSG_Graph_int(builtins.object)
     |  NSG_Graph_int(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, *args)
     |
     |  get_neighbors(self, i, neighbors)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_NSG_Graph_int(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  K
     |      nb of neighbors per node
     |
     |  N
     |      total nb of nodes
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  data
     |      the flattened adjacency matrix, size N-by-K
     |
     |  own_fields
     |      the underlying data owned by itself or not
     |
     |  thisown
     |      The membership flag

    class NegativeDistanceComputer(DistanceComputer)
     |  NegativeDistanceComputer(basedis_)
     |
     |  Method resolution order:
     |      NegativeDistanceComputer
     |      DistanceComputer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, i)
     |      compute distance of vector i to current query
     |
     |  __init__(self, basedis_)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
     |      compute distances of current query to 4 stored vectors.
     |      certain DistanceComputer implementations may benefit
     |      heavily from this.
     |
     |  set_query(self, x)
     |      called before computing distances. Pointer x should remain valid
     |      while operator () is called
     |
     |  symmetric_dis(self, i, j)
     |      compute distance between two stored vectors
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_NegativeDistanceComputer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  basedis
     |      owned by this
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from DistanceComputer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Neighbor(builtins.object)
     |  Neighbor(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __lt__(self, other)
     |      Return self<value.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Neighbor(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  distance
     |
     |  flag
     |
     |  id
     |
     |  thisown
     |      The membership flag

    class NeuralNetCodec(builtins.object)
     |  NeuralNetCodec(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, codes)
     |
     |  encode(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_NeuralNetCodec(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |
     |  thisown
     |      The membership flag

    class Nhood(builtins.object)
     |  Nhood(*args)
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  insert(self, id, dist)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Nhood(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  nn_new
     |
     |  nn_old
     |
     |  pool
     |
     |  rnn_new
     |
     |  rnn_old
     |
     |  thisown
     |      The membership flag

    class NormalizationTransform(VectorTransform)
     |  NormalizationTransform(*args)
     |
     |  per-vector normalization
     |
     |  Method resolution order:
     |      NormalizationTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |       apply the transformation and return the result in a provided matrix
     |      :type n: int
     |      :param n: number of vectors to transform
     |      :type x: float
     |      :param x: input vectors, size n * d_in
     |      :type xt: float
     |      :param xt: output vectors, size n * d_out
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      Identity transform since norm is not revertible
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x) from VectorTransform
     |       Perform training on a representative set of vectors. Does
     |      nothing by default.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_NormalizationTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  norm
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class OPQMatrix(LinearTransform)
     |  OPQMatrix(d=0, M_in=1, d2=-1)
     |
     |   Applies a rotation to align the dimensions with a PQ to minimize
     |   the reconstruction error. Can be used before an IndexPQ or an
     |   IndexIVFPQ. The method is the non-parametric version described in:
     |
     |  "Optimized Product Quantization for Approximate Nearest Neighbor Search"
     |  Tiezheng Ge, Kaiming He, Qifa Ke, Jian Sun, CVPR'13
     |
     |  Method resolution order:
     |      OPQMatrix
     |      LinearTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, d=0, M_in=1, d2=-1)
     |      if d2 != -1, output vectors of this dimension
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_OPQMatrix(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |      nb of subquantizers
     |
     |  max_train_points
     |      if there are too many training points, resample
     |
     |  niter
     |      Number of outer training iterations
     |
     |  niter_pq
     |      Number of training iterations for the PQ
     |
     |  niter_pq_0
     |      same, for the first outer iteration
     |
     |  pq
     |      if non-NULL, use this product quantizer for training
     |      should be constructed with (d_out, M, _)
     |
     |  thisown
     |      The membership flag
     |
     |  verbose
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from LinearTransform:
     |
     |  apply_noalloc(self, n, x, xt)
     |      same as apply, but result is pre-allocated
     |
     |  check_identical(self, other)
     |
     |  print_if_verbose(self, name, mat, n, d)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      works only if is_orthonormal
     |
     |  set_is_orthonormal(self)
     |      compute A^T * A to set the is_orthonormal flag
     |
     |  transform_transpose(self, n, y, x)
     |      compute x = A^T * (x - b)
     |      is reverse transform if A has orthonormal lines
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from LinearTransform:
     |
     |  A
     |      Transformation matrix, size d_out * d_in
     |
     |  b
     |      bias vector, size d_out
     |
     |  have_bias
     |
     |  is_orthonormal
     |      whether to use the bias term
     |       check if matrix A is orthonormal (enables reverse_transform)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class OneRecallAtRCriterion(AutoTuneCriterion)
     |  OneRecallAtRCriterion(nq, R)
     |
     |  Method resolution order:
     |      OneRecallAtRCriterion
     |      AutoTuneCriterion
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, nq, R)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  evaluate(self, D, I)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_OneRecallAtRCriterion(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  R
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AutoTuneCriterion:
     |
     |  evaluate_c = evaluate(self, D, I)
     |       Evaluate the criterion.
     |
     |      :type D: float
     |      :param D:  size nq * nnn
     |      :type I: int
     |      :param I:  size nq * nnn
     |      :rtype: float
     |      :return: the criterion, between 0 and 1. Larger is better.
     |
     |  set_groundtruth = replacement_set_groundtruth(self, D, I) from faiss.class_wrappers.handle_AutoTuneCriterion.<locals>
     |
     |  set_groundtruth_c = set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
     |       Initializes the gt_D and gt_I vectors. Must be called before evaluating
     |
     |      :type gt_D_in: float
     |      :param gt_D_in:  size nq * gt_nnn
     |      :type gt_I_in: int
     |      :param gt_I_in:  size nq * gt_nnn
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AutoTuneCriterion:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  gt_D
     |      Ground-truth distances (size nq * gt_nnn)
     |
     |  gt_I
     |      Ground-truth indexes (size nq * gt_nnn)
     |
     |  gt_nnn
     |      nb of GT NNs required to evaluate criterion
     |
     |  nnn
     |      nb of NNs that the query should request
     |
     |  nq
     |      nb of queries this criterion is evaluated on

    class OperatingPoint(builtins.object)
     |  Maintains a list of experimental results. Each operating point is a
     |  (perf, t, key) triplet, where higher perf and lower t is
     |  better. The key field is an arbitrary identifier for the operating point.
     |
     |  Includes primitives to extract the Pareto-optimal operating points in the
     |  (perf, t) space.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_OperatingPoint(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  cno
     |      integer identifier
     |
     |  key
     |      key that identifies this op pt
     |
     |  perf
     |      performance measure (output of a Criterion)
     |
     |  t
     |      corresponding execution time (ms)
     |
     |  thisown
     |      The membership flag

    class OperatingPointVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_OperatingPointVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class OperatingPoints(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, perf, t, key, cno=0)
     |      add a performance measure. Return whether it is an optimal point
     |
     |  all_to_gnuplot(self, fname)
     |      output to a format easy to digest by gnuplot
     |
     |  clear(self)
     |
     |  display(self, only_optimal=True)
     |      easy-to-read output
     |
     |  merge_with(self, *args)
     |      add operating points from other to this, with a prefix to the keys
     |
     |  optimal_to_gnuplot(self, fname)
     |
     |  t_for_perf(self, perf)
     |      get time required to obtain a given performance measure
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_OperatingPoints(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  all_pts
     |      all operating points
     |
     |  optimal_pts
     |      optimal operating points, sorted by perf
     |
     |  thisown
     |      The membership flag

    class PCAMatrix(LinearTransform)
     |  PCAMatrix(din=0, dout=0, eigen_power_in=0, random_rotation_in=False)
     |
     |  Applies a principal component analysis on a set of vectors,
     |  with optionally whitening and random rotation.
     |
     |  Method resolution order:
     |      PCAMatrix
     |      LinearTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, din=0, dout=0, eigen_power_in=0, random_rotation_in=False)
     |      both d_in > d_out and d_out < d_in are supported
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  copy_from(self, other)
     |      copy pre-trained PCA matrix
     |
     |  prepare_Ab(self)
     |      called after mean, PCAMat and eigenvalues are computed
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |      train on n vectors. If n < d_in then the eigenvector matrix
     |      will be completed with 0s
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PCAMatrix(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  PCAMat
     |      PCA matrix, size d_in * d_in
     |
     |  balanced_bins
     |      try to distribute output eigenvectors in this many bins
     |
     |  eigen_power
     |       after transformation the components are multiplied by
     |      eigenvalues^eigen_power
     |
     |      =0: no whitening
     |      =-0.5: full whitening
     |
     |  eigenvalues
     |      eigenvalues of covariance matrix (= squared singular values)
     |
     |  epsilon
     |      value added to eigenvalues to avoid division by 0 when whitening
     |
     |  max_points_per_d
     |      ratio between # training vectors and dimension
     |
     |  mean
     |      Mean, size d_in
     |
     |  random_rotation
     |      random rotation after PCA
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from LinearTransform:
     |
     |  apply_noalloc(self, n, x, xt)
     |      same as apply, but result is pre-allocated
     |
     |  check_identical(self, other)
     |
     |  print_if_verbose(self, name, mat, n, d)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      works only if is_orthonormal
     |
     |  set_is_orthonormal(self)
     |      compute A^T * A to set the is_orthonormal flag
     |
     |  transform_transpose(self, n, y, x)
     |      compute x = A^T * (x - b)
     |      is reverse transform if A has orthonormal lines
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from LinearTransform:
     |
     |  A
     |      Transformation matrix, size d_out * d_in
     |
     |  b
     |      bias vector, size d_out
     |
     |  have_bias
     |
     |  is_orthonormal
     |      whether to use the bias term
     |       check if matrix A is orthonormal (enables reverse_transform)
     |
     |  verbose
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class PQDecoder16(builtins.object)
     |  PQDecoder16(code, nbits)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, nbits)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PQDecoder16(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  nbits = 16

    class PQDecoder8(builtins.object)
     |  PQDecoder8(code, nbits)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, nbits)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PQDecoder8(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  nbits = 8

    class PQDecoderGeneric(builtins.object)
     |  PQDecoderGeneric(code, nbits)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, nbits)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PQDecoderGeneric(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  mask
     |
     |  nbits
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  offset
     |
     |  reg
     |
     |  thisown
     |      The membership flag

    class PQEncoder16(builtins.object)
     |  PQEncoder16(code, nbits)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, nbits)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  encode(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PQEncoder16(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  thisown
     |      The membership flag

    class PQEncoder8(builtins.object)
     |  PQEncoder8(code, nbits)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, nbits)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  encode(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PQEncoder8(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |
     |  thisown
     |      The membership flag

    class PQEncoderGeneric(builtins.object)
     |  PQEncoderGeneric(code, nbits, offset=0)
     |
     |  Methods defined here:
     |
     |  __init__(self, code, nbits, offset=0)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  encode(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PQEncoderGeneric(...)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  nbits
     |      number of bits per subquantizer index
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code
     |      code for this vector
     |
     |  offset
     |
     |  reg
     |
     |  thisown
     |      The membership flag

    class Panorama(builtins.object)
     |  Panorama(code_size, n_levels, batch_size)
     |
     |  Implements the core logic of Panorama-based refinement.
     |  arXiv: https://arxiv.org/abs/2510.00566
     |
     |  Panorama partitions the dimensions of all vectors into L contiguous levels.
     |  During the refinement stage of ANNS, it computes distances between the query
     |  and its candidates level-by-level. After processing each level, it prunes the
     |  candidates whose lower bound exceeds the k-th best distance.
     |
     |  In order to enable speedups, the dimensions (or codes) of each vector are
     |  stored in a batched, level-major manner. Within each batch of b vectors, the
     |  dimensions corresponding to level 1 will be stored first (for all elements in
     |  that batch), followed by level 2, and so on. This allows for efficient memory
     |  access patterns.
     |
     |  Coupled with the appropriate orthogonal PreTransform (e.g. PCA, Cayley,
     |  etc.), Panorama can prune the vast majority of dimensions, greatly
     |  accelerating the refinement stage.
     |
     |  Methods defined here:
     |
     |  __init__(self, code_size, n_levels, batch_size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_cumulative_sums(self, cumsum_base, offset, n_entry, vectors)
     |      Helper method to compute the cumulative sums of the codes.
     |      The cumsums also follow the level-oriented batch layout to minimize the
     |      number of random memory accesses.
     |
     |  compute_query_cum_sums(self, query, query_cum_sums)
     |      Compute the cumulative sums of the query vector.
     |
     |  copy_codes_to_level_layout(self, codes, offset, n_entry, code)
     |      Helper method to copy codes into level-oriented batch layout at a given
     |      offset in the list.
     |
     |  copy_entry(self, dest_codes, src_codes, dest_cum_sums, src_cum_sums, dest_idx, src_idx)
     |      Copy single entry (code and cum_sum) from one location to another.
     |
     |  reconstruct(self, key, recons, codes_base)
     |      Panorama's core progressive filtering algorithm:
     |      Process vectors in batches for cache efficiency. For each batch:
     |      1. Apply ID selection filter and initialize distances
     |      (||y||^2 + ||x||^2).
     |      2. Maintain an "active set" of candidate indices that haven't been
     |      pruned yet.
     |      3. For each level, refine distances incrementally and compact the active
     |      set:
     |         - Compute dot product for current level: exact_dist -= 2*<x,y>.
     |         - Use Cauchy-Schwarz bound on remaining levels to get lower bound
     |         - Prune candidates whose lower bound exceeds k-th best distance.
     |         - Compact active_indices to remove pruned candidates (branchless)
     |      4. After all levels, survivors are exact distances; update heap.
     |      This achieves early termination while maintaining SIMD-friendly
     |      sequential access patterns in the level-oriented storage layout.
     |
     |  set_derived_values(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Panorama(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  batch_size
     |
     |  code_size
     |
     |  d
     |
     |  level_width
     |
     |  level_width_floats
     |
     |  n_levels
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  kDefaultBatchSize = 128

    class PanoramaStats(builtins.object)
     |  Statistics are not robust to internal threading nor to
     |  concurrent Panorama searches. Use these values in a
     |  single-threaded context to accurately gauge Panorama's
     |  pruning effectiveness.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, other)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PanoramaStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ratio_dims_scanned
     |
     |  thisown
     |      The membership flag
     |
     |  total_dims
     |
     |  total_dims_scanned

    class ParameterRange(builtins.object)
     |  possible values of a parameter, sorted from least to most expensive/accurate
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ParameterRange(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name
     |
     |  thisown
     |      The membership flag
     |
     |  values

    class ParameterRangeVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ParameterRangeVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class ParameterSpace(builtins.object)
     |  Uses a-priori knowledge on the Faiss indexes to extract tunable parameters.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_range(self, name)
     |      add a new parameter (or return it if it exists)
     |
     |  combination_ge(self, c1, c2)
     |      returns whether combinations c1 >= c2 in the tuple sense
     |
     |  combination_name(self, cno)
     |      get string representation of the combination
     |
     |  display(self)
     |      print a description on stdout
     |
     |  explore = replacement_explore(self, index, xq, crit) from faiss.class_wrappers.handle_ParameterSpace.<locals>
     |
     |  explore_c = explore(self, index, nq, xq, crit, ops)
     |       explore operating points
     |      :type index: :py:class:`Index`
     |      :param index:   index to run on
     |      :type xq: float
     |      :param xq:      query vectors (size nq * index.d)
     |      :type crit: :py:class:`AutoTuneCriterion`
     |      :param crit:    selection criterion
     |      :type ops: :py:class:`OperatingPoints`
     |      :param ops:     resulting operating points
     |
     |  initialize(self, index)
     |      initialize with reasonable parameters for the index
     |
     |  n_combinations(self)
     |      nb of combinations, = product of values sizes
     |
     |  set_index_parameter(self, *args)
     |      *Overload 1:*
     |      set one of the parameters
     |
     |      |
     |
     |      *Overload 2:*
     |      set one of the parameters on a binary index
     |
     |  set_index_parameters(self, *args)
     |      *Overload 1:*
     |      set a combination of parameters on an index
     |
     |      |
     |
     |      *Overload 2:*
     |      set a combination of parameters described by a string
     |
     |      |
     |
     |      *Overload 3:*
     |      set a combination of parameters on a binary index
     |
     |      |
     |
     |      *Overload 4:*
     |      set a combination of parameters described by a string on a binary index
     |
     |  update_bounds(self, cno, op, upper_bound_perf, lower_bound_t)
     |       find an upper bound on the performance and a lower bound on t
     |      for configuration cno given another operating point op
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ParameterSpace(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  batchsize
     |      maximum number of queries to submit at a time.
     |
     |  min_test_duration
     |      run tests several times until they reach at least this
     |      duration (to avoid jittering in MT mode)
     |
     |  n_experiments
     |      nb of experiments during optimization (0 = try all combinations)
     |
     |  parameter_ranges
     |      all tunable parameters
     |
     |  thisown
     |      The membership flag
     |
     |  thread_over_batches
     |      use multithreading over batches (useful to benchmark
     |      independent single-searches)
     |
     |  verbose
     |      verbosity during exploration

    class PartitionStats(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PartitionStats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  bisect_cycles
     |
     |  compress_cycles
     |
     |  thisown
     |      The membership flag

    class PermutationObjective(builtins.object)
     |  PermutationObjective(*args, **kwargs)
     |
     |  abstract class for the loss function
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_cost(self, perm)
     |
     |  cost_update(self, perm, iw, jw)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PermutationObjective(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n
     |
     |  thisown
     |      The membership flag

    class PolysemousTraining(SimulatedAnnealingParameters)
     |  optimizes the order of indices in a ProductQuantizer
     |
     |  Method resolution order:
     |      PolysemousTraining
     |      SimulatedAnnealingParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  memory_usage_per_thread(self, pq)
     |      make sure we don't blow up the memory
     |
     |  optimize_pq_for_hamming(self, pq, n, x)
     |      reorder the centroids so that the Hamming distance becomes a
     |      good approximation of the SDC distance (called by train)
     |
     |  optimize_ranking(self, pq, n, x)
     |      called by optimize_pq_for_hamming
     |
     |  optimize_reproduce_distances(self, pq)
     |      called by optimize_pq_for_hamming
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PolysemousTraining(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  dis_weight_factor
     |      decay of exp that weights distance loss
     |
     |  log_pattern
     |
     |  max_memory
     |      refuse to train if it would require more than that amount of RAM
     |
     |  ntrain_permutation
     |       use 1/4 of the training points for the optimization, with
     |      max. ntrain_permutation. If ntrain_permutation == 0: train on
     |      centroids
     |
     |  optimization_type
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  OT_None = 0
     |
     |  OT_Ranking_weighted_diff = 2
     |
     |  OT_ReproduceDistances_affine = 1
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SimulatedAnnealingParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  init_random
     |
     |  init_temperature
     |
     |  n_iter
     |
     |  n_redo
     |
     |  only_bit_flips
     |
     |  seed
     |
     |  temperature_decay
     |
     |  verbose

    class ProductAdditiveQuantizer(AdditiveQuantizer)
     |  ProductAdditiveQuantizer(*args)
     |
     |   Product Additive Quantizers
     |
     |  The product additive quantizer is a variant of AQ and PQ.
     |  It first splits the vector space into multiple orthogonal sub-spaces
     |  just like PQ does. And then it quantizes each sub-space by an independent
     |  additive quantizer.
     |
     |  Method resolution order:
     |      ProductAdditiveQuantizer
     |      AdditiveQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |       Construct a product additive quantizer.
     |
     |      The additive quantizers passed in will be cloned into the
     |      ProductAdditiveQuantizer object.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type aqs: std::vector< faiss::AdditiveQuantizer * >
     |      :param aqs:    sub-additive quantizers
     |      :type search_type: int, optional
     |      :param search_type:  AQ search type
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
     |       Compute inner-product look-up tables. Used in the search functions.
     |
     |      :type xq: float
     |      :param xq:     query vector, size (n, d)
     |      :type LUT: float
     |      :param LUT:    look-up table, size (n, total_codebook_size)
     |      :type alpha: float, optional
     |      :param alpha:  compute alpha * inner-product
     |      :type ld_lut: int, optional
     |      :param ld_lut:  leading dimension of LUT
     |
     |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |      :type centroids: float, optional
     |      :param centroids:  centroids to be added to x, size n * d
     |
     |  compute_unpacked_codes(self, x, codes, n, centroids=None)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, codes, x, n)
     |       Decode a set of vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  decode_unpacked(self, codes, x, n, ld_codes=-1)
     |       Decode a set of vectors in non-packed format
     |
     |      :type codes: int
     |      :param codes:  codes to decode, size n * ld_codes
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  init(self, d, aqs, search_type)
     |
     |  subquantizer(self, m)
     |      Train the product additive quantizer
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProductAdditiveQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  nsplits
     |      number of sub-vectors we split a vector into
     |
     |  quantizers
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveQuantizer:
     |
     |  compute_centroid_norms(self, norms)
     |       For L2 search we need the L2 norms of the centroids
     |
     |      :type norms: float
     |      :param norms:    output norms table, size total_codebook_size
     |
     |  compute_codebook_tables(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  decode_64bit(self, n, x)
     |      decoding function for a code in a 64-bit word
     |
     |  decode_qcint(self, c)
     |      decode norm by non-uniform scalar quantization
     |
     |  encode_norm(self, norm)
     |      encode a norm into norm_bits bits
     |
     |  encode_qcint(self, x)
     |      encode norm by non-uniform scalar quantization
     |
     |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
     |      Exact L2 search, with precomputed norms
     |
     |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
     |      exact IP search
     |
     |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
     |       pack a series of code to bit-compact format
     |
     |      :type codes: int
     |      :param codes:        codes to be packed, size n * code_size
     |      :type packed_codes: uint8_t
     |      :param packed_codes: output bit-compact codes
     |      :type ld_codes: int, optional
     |      :param ld_codes:     leading dimension of codes
     |      :type norms: float, optional
     |      :param norms:        norms of the vectors (size n). Will be computed if
     |                              needed but not provided
     |      :type centroids: float, optional
     |      :param centroids:    centroids to be added to x, size n * d
     |
     |  set_derived_values(self)
     |      Train the norm quantizer
     |
     |  train_norm(self, n, norms)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveQuantizer:
     |
     |  M
     |      number of codebooks
     |
     |  centroid_norms
     |      norms of all codebook entries (size total_codebook_size)
     |
     |  codebook_cross_products
     |      dot products of all codebook entries with the previous codebooks
     |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
     |
     |  codebook_offsets
     |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
     |      in the codebooks table of size total_codebook_size by d
     |
     |  codebooks
     |      codebooks
     |
     |  is_trained
     |      is trained or not
     |
     |  max_mem_distances
     |      norms and distance matrixes with beam search can get large, so use this
     |      to control for the amount of memory that can be allocated
     |
     |  nbits
     |      bits for each step
     |
     |  norm_bits
     |      bits allocated for the norms
     |
     |  norm_max
     |
     |  norm_min
     |      min/max for quantization of norms
     |
     |  norm_tabs
     |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
     |      store norms of codebook entries for 4-bit fastscan
     |
     |  only_8bit
     |      are all nbits = 8 (use faster decoder)
     |
     |  qnorm
     |      store and search norms
     |
     |  search_type
     |      Also determines what's in the codes
     |
     |  tot_bits
     |      total number of bits (indexes + norms)
     |
     |  total_codebook_size
     |      size of the codebook in vectors
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AdditiveQuantizer:
     |
     |  ST_LUT_nonorm = 1
     |
     |  ST_count = 10
     |
     |  ST_decompress = 0
     |
     |  ST_norm_cqint4 = 7
     |
     |  ST_norm_cqint8 = 6
     |
     |  ST_norm_float = 3
     |
     |  ST_norm_from_LUT = 2
     |
     |  ST_norm_lsq2x4 = 8
     |
     |  ST_norm_qint4 = 5
     |
     |  ST_norm_qint8 = 4
     |
     |  ST_norm_rq2x4 = 9
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class ProductLocalSearchQuantizer(ProductAdditiveQuantizer)
     |  ProductLocalSearchQuantizer(*args)
     |
     |  Product Local Search Quantizer
     |
     |  Method resolution order:
     |      ProductLocalSearchQuantizer
     |      ProductAdditiveQuantizer
     |      AdditiveQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |       Construct a product LSQ object.
     |
     |      :type d: int
     |      :param d:   dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of sub-vectors we split a vector into
     |      :type Msub: int
     |      :param Msub:     number of codebooks of each LSQ
     |      :type nbits: int
     |      :param nbits:    bits for each step
     |      :type search_type: int, optional
     |      :param search_type:  AQ search type
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProductLocalSearchQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ProductAdditiveQuantizer:
     |
     |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
     |       Compute inner-product look-up tables. Used in the search functions.
     |
     |      :type xq: float
     |      :param xq:     query vector, size (n, d)
     |      :type LUT: float
     |      :param LUT:    look-up table, size (n, total_codebook_size)
     |      :type alpha: float, optional
     |      :param alpha:  compute alpha * inner-product
     |      :type ld_lut: int, optional
     |      :param ld_lut:  leading dimension of LUT
     |
     |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |      :type centroids: float, optional
     |      :param centroids:  centroids to be added to x, size n * d
     |
     |  compute_unpacked_codes(self, x, codes, n, centroids=None)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, codes, x, n)
     |       Decode a set of vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  decode_unpacked(self, codes, x, n, ld_codes=-1)
     |       Decode a set of vectors in non-packed format
     |
     |      :type codes: int
     |      :param codes:  codes to decode, size n * ld_codes
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  init(self, d, aqs, search_type)
     |
     |  subquantizer(self, m)
     |      Train the product additive quantizer
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ProductAdditiveQuantizer:
     |
     |  nsplits
     |      number of sub-vectors we split a vector into
     |
     |  quantizers
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveQuantizer:
     |
     |  compute_centroid_norms(self, norms)
     |       For L2 search we need the L2 norms of the centroids
     |
     |      :type norms: float
     |      :param norms:    output norms table, size total_codebook_size
     |
     |  compute_codebook_tables(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  decode_64bit(self, n, x)
     |      decoding function for a code in a 64-bit word
     |
     |  decode_qcint(self, c)
     |      decode norm by non-uniform scalar quantization
     |
     |  encode_norm(self, norm)
     |      encode a norm into norm_bits bits
     |
     |  encode_qcint(self, x)
     |      encode norm by non-uniform scalar quantization
     |
     |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
     |      Exact L2 search, with precomputed norms
     |
     |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
     |      exact IP search
     |
     |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
     |       pack a series of code to bit-compact format
     |
     |      :type codes: int
     |      :param codes:        codes to be packed, size n * code_size
     |      :type packed_codes: uint8_t
     |      :param packed_codes: output bit-compact codes
     |      :type ld_codes: int, optional
     |      :param ld_codes:     leading dimension of codes
     |      :type norms: float, optional
     |      :param norms:        norms of the vectors (size n). Will be computed if
     |                              needed but not provided
     |      :type centroids: float, optional
     |      :param centroids:    centroids to be added to x, size n * d
     |
     |  set_derived_values(self)
     |      Train the norm quantizer
     |
     |  train_norm(self, n, norms)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveQuantizer:
     |
     |  M
     |      number of codebooks
     |
     |  centroid_norms
     |      norms of all codebook entries (size total_codebook_size)
     |
     |  codebook_cross_products
     |      dot products of all codebook entries with the previous codebooks
     |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
     |
     |  codebook_offsets
     |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
     |      in the codebooks table of size total_codebook_size by d
     |
     |  codebooks
     |      codebooks
     |
     |  is_trained
     |      is trained or not
     |
     |  max_mem_distances
     |      norms and distance matrixes with beam search can get large, so use this
     |      to control for the amount of memory that can be allocated
     |
     |  nbits
     |      bits for each step
     |
     |  norm_bits
     |      bits allocated for the norms
     |
     |  norm_max
     |
     |  norm_min
     |      min/max for quantization of norms
     |
     |  norm_tabs
     |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
     |      store norms of codebook entries for 4-bit fastscan
     |
     |  only_8bit
     |      are all nbits = 8 (use faster decoder)
     |
     |  qnorm
     |      store and search norms
     |
     |  search_type
     |      Also determines what's in the codes
     |
     |  tot_bits
     |      total number of bits (indexes + norms)
     |
     |  total_codebook_size
     |      size of the codebook in vectors
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AdditiveQuantizer:
     |
     |  ST_LUT_nonorm = 1
     |
     |  ST_count = 10
     |
     |  ST_decompress = 0
     |
     |  ST_norm_cqint4 = 7
     |
     |  ST_norm_cqint8 = 6
     |
     |  ST_norm_float = 3
     |
     |  ST_norm_from_LUT = 2
     |
     |  ST_norm_lsq2x4 = 8
     |
     |  ST_norm_qint4 = 5
     |
     |  ST_norm_qint8 = 4
     |
     |  ST_norm_rq2x4 = 9
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class ProductQuantizer(Quantizer)
     |  ProductQuantizer(*args)
     |
     |   Product Quantizer.
     |  PQ is trained using k-means, minimizing the L2 distance to centroids.
     |  PQ supports L2 and Inner Product search, however the quantization error is
     |  biased towards L2 distance.
     |
     |  Method resolution order:
     |      ProductQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  clear_transposed_centroids(self)
     |      Clear transposed centroids table so ones are no longer used.
     |
     |  compute_code(self, x, code)
     |      Quantize one vector with the product quantizer
     |
     |  compute_code_from_distance_table(self, tab, code)
     |      If we happen to have the distance tables precomputed, this is
     |      more efficient to compute the codes.
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |      same as compute_code for several vectors
     |
     |  compute_codes_with_assign_index(self, x, codes, n)
     |      speed up code assignment using assign_index
     |      (non-const because the index is changed)
     |
     |  compute_distance_table(self, x, dis_table)
     |       Compute distance table for one vector.
     |
     |      The distance table for x = [x_0 x_1 .. x_(M-1)] is a M * ksub
     |      matrix that contains
     |
     |        dis_table (m, j) = || x_m - c_(m, j)||^2
     |        for m = 0..M-1 and j = 0 .. ksub - 1
     |
     |      where c_(m, j) is the centroid no j of sub-quantizer m.
     |
     |      :type x: float
     |      :param x:         input vector size d
     |      :type dis_table: float
     |      :param dis_table: output table, size M * ksub
     |
     |  compute_distance_tables(self, nx, x, dis_tables)
     |       compute distance table for several vectors
     |      :type nx: int
     |      :param nx:        nb of input vectors
     |      :type x: float
     |      :param x:         input vector size nx * d
     |      :param dis_table: output table, size nx * M * ksub
     |
     |  compute_inner_prod_table(self, x, dis_table)
     |
     |  compute_inner_prod_tables(self, nx, x, dis_tables)
     |
     |  compute_sdc_table(self)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, *args)
     |      decode a vector from a given code (or n vectors if third argument)
     |
     |  get_centroids(self, m, i)
     |      return the centroids associated with subvector m
     |
     |  search(self, x, nx, codes, ncodes, res, init_finalize_heap=True)
     |       perform a search (L2 distance)
     |      :type x: float
     |      :param x:        query vectors, size nx * d
     |      :type nx: int
     |      :param nx:       nb of queries
     |      :type codes: uint8_t
     |      :param codes:    database codes, size ncodes * code_size
     |      :type ncodes: int
     |      :param ncodes:   nb of nb vectors
     |      :type res: :py:class:`float_maxheap_array_t`
     |      :param res:      heap array to store results (nh == nx)
     |      :type init_finalize_heap: boolean, optional
     |      :param init_finalize_heap:  initialize heap (input) and sort (output)?
     |
     |  search_ip(self, x, nx, codes, ncodes, res, init_finalize_heap=True)
     |      same as search, but with inner product similarity
     |
     |  search_sdc(self, qcodes, nq, bcodes, ncodes, res, init_finalize_heap=True)
     |
     |  set_derived_values(self)
     |      compute derived values when d, M and nbits have been set
     |
     |  set_params(self, centroids, m)
     |      Define the centroids for subquantizer m
     |
     |  sync_transposed_centroids(self)
     |      Sync transposed centroids with regular centroids. This call
     |      is needed if centroids were edited directly.
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProductQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  M
     |      number of subquantizers
     |
     |  assign_index
     |      if non-NULL, use this index for assignment (should be of size
     |      d / M)
     |
     |  centroids
     |      Centroid table, size M * ksub * dsub.
     |      Layout: (M, ksub, dsub)
     |
     |  centroids_sq_lengths
     |      Squared lengths of centroids, size M * ksub
     |      Layout: (M, ksub)
     |
     |  cp
     |      parameters used during clustering
     |
     |  dsub
     |      dimensionality of each subvector
     |
     |  ksub
     |      number of centroids for each subquantizer
     |
     |  nbits
     |      number of bits per quantization index
     |
     |  sdc_table
     |      Symmetric Distance Table
     |
     |  thisown
     |      The membership flag
     |
     |  train_type
     |
     |  transposed_centroids
     |      Transposed centroid table, size M * ksub * dsub.
     |      Layout: (dsub, M, ksub)
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  Train_default = 0
     |
     |  Train_hot_start = 1
     |
     |  Train_hypercube = 3
     |
     |  Train_hypercube_pca = 4
     |
     |  Train_shared = 2
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class ProductResidualQuantizer(ProductAdditiveQuantizer)
     |  ProductResidualQuantizer(*args)
     |
     |  Product Residual Quantizer
     |
     |  Method resolution order:
     |      ProductResidualQuantizer
     |      ProductAdditiveQuantizer
     |      AdditiveQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |       Construct a product RQ object.
     |
     |      :type d: int
     |      :param d:   dimensionality of the input vectors
     |      :type nsplits: int
     |      :param nsplits:  number of sub-vectors we split a vector into
     |      :type Msub: int
     |      :param Msub:     number of codebooks of each RQ
     |      :type nbits: int
     |      :param nbits:    bits for each step
     |      :type search_type: int, optional
     |      :param search_type:  AQ search type
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProductResidualQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ProductAdditiveQuantizer:
     |
     |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
     |       Compute inner-product look-up tables. Used in the search functions.
     |
     |      :type xq: float
     |      :param xq:     query vector, size (n, d)
     |      :type LUT: float
     |      :param LUT:    look-up table, size (n, total_codebook_size)
     |      :type alpha: float, optional
     |      :param alpha:  compute alpha * inner-product
     |      :type ld_lut: int, optional
     |      :param ld_lut:  leading dimension of LUT
     |
     |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |      :type centroids: float, optional
     |      :param centroids:  centroids to be added to x, size n * d
     |
     |  compute_unpacked_codes(self, x, codes, n, centroids=None)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, codes, x, n)
     |       Decode a set of vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  decode_unpacked(self, codes, x, n, ld_codes=-1)
     |       Decode a set of vectors in non-packed format
     |
     |      :type codes: int
     |      :param codes:  codes to decode, size n * ld_codes
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  init(self, d, aqs, search_type)
     |
     |  subquantizer(self, m)
     |      Train the product additive quantizer
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ProductAdditiveQuantizer:
     |
     |  nsplits
     |      number of sub-vectors we split a vector into
     |
     |  quantizers
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveQuantizer:
     |
     |  compute_centroid_norms(self, norms)
     |       For L2 search we need the L2 norms of the centroids
     |
     |      :type norms: float
     |      :param norms:    output norms table, size total_codebook_size
     |
     |  compute_codebook_tables(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  decode_64bit(self, n, x)
     |      decoding function for a code in a 64-bit word
     |
     |  decode_qcint(self, c)
     |      decode norm by non-uniform scalar quantization
     |
     |  encode_norm(self, norm)
     |      encode a norm into norm_bits bits
     |
     |  encode_qcint(self, x)
     |      encode norm by non-uniform scalar quantization
     |
     |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
     |      Exact L2 search, with precomputed norms
     |
     |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
     |      exact IP search
     |
     |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
     |       pack a series of code to bit-compact format
     |
     |      :type codes: int
     |      :param codes:        codes to be packed, size n * code_size
     |      :type packed_codes: uint8_t
     |      :param packed_codes: output bit-compact codes
     |      :type ld_codes: int, optional
     |      :param ld_codes:     leading dimension of codes
     |      :type norms: float, optional
     |      :param norms:        norms of the vectors (size n). Will be computed if
     |                              needed but not provided
     |      :type centroids: float, optional
     |      :param centroids:    centroids to be added to x, size n * d
     |
     |  set_derived_values(self)
     |      Train the norm quantizer
     |
     |  train_norm(self, n, norms)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveQuantizer:
     |
     |  M
     |      number of codebooks
     |
     |  centroid_norms
     |      norms of all codebook entries (size total_codebook_size)
     |
     |  codebook_cross_products
     |      dot products of all codebook entries with the previous codebooks
     |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
     |
     |  codebook_offsets
     |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
     |      in the codebooks table of size total_codebook_size by d
     |
     |  codebooks
     |      codebooks
     |
     |  is_trained
     |      is trained or not
     |
     |  max_mem_distances
     |      norms and distance matrixes with beam search can get large, so use this
     |      to control for the amount of memory that can be allocated
     |
     |  nbits
     |      bits for each step
     |
     |  norm_bits
     |      bits allocated for the norms
     |
     |  norm_max
     |
     |  norm_min
     |      min/max for quantization of norms
     |
     |  norm_tabs
     |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
     |      store norms of codebook entries for 4-bit fastscan
     |
     |  only_8bit
     |      are all nbits = 8 (use faster decoder)
     |
     |  qnorm
     |      store and search norms
     |
     |  search_type
     |      Also determines what's in the codes
     |
     |  tot_bits
     |      total number of bits (indexes + norms)
     |
     |  total_codebook_size
     |      size of the codebook in vectors
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AdditiveQuantizer:
     |
     |  ST_LUT_nonorm = 1
     |
     |  ST_count = 10
     |
     |  ST_decompress = 0
     |
     |  ST_norm_cqint4 = 7
     |
     |  ST_norm_cqint8 = 6
     |
     |  ST_norm_float = 3
     |
     |  ST_norm_from_LUT = 2
     |
     |  ST_norm_lsq2x4 = 8
     |
     |  ST_norm_qint4 = 5
     |
     |  ST_norm_qint8 = 4
     |
     |  ST_norm_rq2x4 = 9
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class ProgressiveDimClustering(ProgressiveDimClusteringParameters)
     |  ProgressiveDimClustering(*args)
     |
     |   K-means clustering with progressive dimensions used
     |
     |  The clustering first happens in dim 1, then with exponentially increasing
     |  dimension until d (I steps). This is typically applied after a PCA
     |  transformation (optional). Reference:
     |
     |  "Improved Residual Vector Quantization for High-dimensional Approximate
     |  Nearest Neighbor Search"
     |
     |  Shicong Liu, Hongtao Lu, Junru Shao, AAAI'15
     |
     |  https://arxiv.org/abs/1509.05195
     |
     |  Method resolution order:
     |      ProgressiveDimClustering
     |      ProgressiveDimClusteringParameters
     |      ClusteringParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  train(self, n, x, factory)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProgressiveDimClustering(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centroids
     |      centroids (k * d)
     |
     |  d
     |      dimension of the vectors
     |
     |  iteration_stats
     |      stats at every iteration of clustering
     |
     |  k
     |      nb of centroids
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ProgressiveDimClusteringParameters:
     |
     |  apply_pca
     |      apply PCA on input
     |
     |  progressive_dim_steps
     |      number of incremental steps
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ClusteringParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² initialization.
     |      Only used when init_method = AFK_MC2.
     |      Longer chains give better approximation but are slower.
     |
     |  check_input_data_for_NaNs
     |      whether to check for NaNs in an input data
     |
     |  decode_block_size
     |      when the training set is encoded, batch size of the codec decoder
     |
     |  early_stop_threshold
     |      Early stop threshold, the range is [0, 1].
     |      The value of 0 implies a default Faiss behavior,
     |      so the training process stops only if an error
     |      is unchanged from the previous iteration.
     |
     |  frozen_centroids
     |      Use the subset of centroids provided as input and do not change them
     |      during iterations
     |
     |  init_method
     |      Initialization method for centroids.
     |      RANDOM: uniform random sampling (default, current behavior)
     |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
     |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
     |
     |  int_centroids
     |      round centroids coordinates to integer after each iteration?
     |
     |  max_points_per_centroid
     |      to limit size of dataset, otherwise the training set is subsampled
     |
     |  min_points_per_centroid
     |      If fewer than this number of training vectors per centroid are provided,
     |      writes a warning. Note that fewer than 1 point per centroid raises an
     |      exception.
     |
     |  niter
     |      number of clustering iterations
     |
     |  nredo
     |      redo clustering this many times and keep the clusters with the best
     |      objective
     |
     |  seed
     |      seed for the random number generator.
     |      negative values lead to seeding an internal rng with
     |      std::high_resolution_clock.
     |
     |  spherical
     |      whether to normalize centroids after each iteration (useful for inner
     |      product clustering)
     |
     |  update_index
     |      re-train index after each iteration?
     |
     |  use_faster_subsampling
     |      Whether to use splitmix64-based random number generator for subsampling,
     |      which is faster, but may pick duplicate points.
     |
     |  verbose

    class ProgressiveDimClusteringParameters(ClusteringParameters)
     |  Method resolution order:
     |      ProgressiveDimClusteringParameters
     |      ClusteringParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProgressiveDimClusteringParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  apply_pca
     |      apply PCA on input
     |
     |  progressive_dim_steps
     |      number of incremental steps
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ClusteringParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² initialization.
     |      Only used when init_method = AFK_MC2.
     |      Longer chains give better approximation but are slower.
     |
     |  check_input_data_for_NaNs
     |      whether to check for NaNs in an input data
     |
     |  decode_block_size
     |      when the training set is encoded, batch size of the codec decoder
     |
     |  early_stop_threshold
     |      Early stop threshold, the range is [0, 1].
     |      The value of 0 implies a default Faiss behavior,
     |      so the training process stops only if an error
     |      is unchanged from the previous iteration.
     |
     |  frozen_centroids
     |      Use the subset of centroids provided as input and do not change them
     |      during iterations
     |
     |  init_method
     |      Initialization method for centroids.
     |      RANDOM: uniform random sampling (default, current behavior)
     |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
     |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
     |
     |  int_centroids
     |      round centroids coordinates to integer after each iteration?
     |
     |  max_points_per_centroid
     |      to limit size of dataset, otherwise the training set is subsampled
     |
     |  min_points_per_centroid
     |      If fewer than this number of training vectors per centroid are provided,
     |      writes a warning. Note that fewer than 1 point per centroid raises an
     |      exception.
     |
     |  niter
     |      number of clustering iterations
     |
     |  nredo
     |      redo clustering this many times and keep the clusters with the best
     |      objective
     |
     |  seed
     |      seed for the random number generator.
     |      negative values lead to seeding an internal rng with
     |      std::high_resolution_clock.
     |
     |  spherical
     |      whether to normalize centroids after each iteration (useful for inner
     |      product clustering)
     |
     |  update_index
     |      re-train index after each iteration?
     |
     |  use_faster_subsampling
     |      Whether to use splitmix64-based random number generator for subsampling,
     |      which is faster, but may pick duplicate points.
     |
     |  verbose

    class ProgressiveDimIndexFactory(builtins.object)
     |  generates an index suitable for clustering when called
     |
     |  Methods defined here:
     |
     |  __call__(self, dim)
     |      ownership transferred to caller
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ProgressiveDimIndexFactory(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class PyCallbackIDSelector(IDSelector)
     |  PyCallbackIDSelector(callback)
     |
     |  Method resolution order:
     |      PyCallbackIDSelector
     |      IDSelector
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, callback)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  is_member(self, id)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PyCallbackIDSelector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  callback
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IDSelector:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class PyCallbackIOReader(IOReader)
     |  PyCallbackIOReader(*args)
     |
     |  Method resolution order:
     |      PyCallbackIOReader
     |      IOReader
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptrv, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, *args)
     |       Callback: Python function that takes a size and returns a
     |      bytes object with the resulting read
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PyCallbackIOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  bs
     |
     |  callback
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOReader:
     |
     |  filedescriptor(self)
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOReader:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class PyCallbackIOWriter(IOWriter)
     |  PyCallbackIOWriter(*args)
     |
     |  Method resolution order:
     |      PyCallbackIOWriter
     |      IOWriter
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptrv, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, *args)
     |      Callback: Python function that takes a bytes object and
     |      returns the number of bytes successfully written.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PyCallbackIOWriter(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  bs
     |
     |  callback
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOWriter:
     |
     |  filedescriptor(self)
     |
     |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOWriter:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class PyCallbackShardingFunction(ShardingFunction)
     |  PyCallbackShardingFunction(*args)
     |
     |  Method resolution order:
     |      PyCallbackShardingFunction
     |      ShardingFunction
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, i, shard_count)
     |      Call self as a function.
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PyCallbackShardingFunction(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  callback
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ShardingFunction:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class PythonInterruptCallback(InterruptCallback)
     |  Method resolution order:
     |      PythonInterruptCallback
     |      InterruptCallback
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  want_interrupt(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_PythonInterruptCallback(...)
     |
     |  reset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from InterruptCallback:
     |
     |  check()
     |       check if:
     |      - an interrupt callback is set
     |      - the callback returns true
     |      if this is the case, then throw an exception. Should not be called
     |      from multiple threads.
     |
     |  clear_instance()
     |
     |  get_period_hint(flops)
     |       assuming each iteration takes a certain number of flops, what
     |      is a reasonable interval to check for interrupts?
     |
     |  is_interrupted()
     |      same as check() but return true if is interrupted instead of
     |      throwing. Can be called from multiple threads.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InterruptCallback:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class QINCo(NeuralNetCodec)
     |  QINCo(*args)
     |
     |  Method resolution order:
     |      QINCo
     |      NeuralNetCodec
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_QINCo.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, codes)
     |
     |  encode(self, x)
     |
     |  from_torch(self, qinco) from faiss.class_wrappers.handle_QINCo.<locals>
     |      copy weights from torch.QINCo
     |
     |  get_step(self, i)
     |
     |  original_init = __init__(self, d, K, L, M, h)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_QINCo(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  K
     |
     |  L
     |
     |  codebook0
     |
     |  h
     |
     |  steps
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from NeuralNetCodec:
     |
     |  M
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d

    class QINCoStep(builtins.object)
     |  QINCoStep(*args)
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_QINCoStep.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, xhat, codes)
     |
     |  encode(self, xhat, x, residuals=None)
     |       encode a set of vectors x with initial estimate xhat. Optionally return
     |      the delta to be added to xhat to form the new xhat
     |
     |  from_torch(self, step) from faiss.class_wrappers.handle_QINCoStep.<locals>
     |      copy weights from torch.QINCoStep
     |
     |  get_residual_block(self, i)
     |
     |  original_init = __init__(self, d, K, L, h)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_QINCoStep(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  K
     |
     |  L
     |
     |  MLPconcat
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  codebook
     |
     |  d
     |      d: input dim, K: codebook size, L: # of residual blocks, h: hidden dim
     |
     |  h
     |
     |  residual_blocks
     |
     |  thisown
     |      The membership flag

    class Quantizer(builtins.object)
     |  Quantizer(*args, **kwargs)
     |
     |  General interface for quantizer objects
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |       Quantize a set of vectors
     |
     |      :type x: float
     |      :param x:        input vectors, size n * d
     |      :type codes: uint8_t
     |      :param codes:    output codes, size n * code_size
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, code, x, n)
     |       Decode a set of vectors
     |
     |      :param codes:    input codes, size n * code_size
     |      :type x: float
     |      :param x:        output vectors, size n * d
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Train the quantizer
     |
     |      :type x: float
     |      :param x:       training vectors, size n * d
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Quantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors
     |
     |  thisown
     |      The membership flag

    class QueryFactorsData(builtins.object)
     |   Query-specific factors computed during search for RaBitQ distance
     |  computation. Used by both IndexRaBitQ and IndexRaBitQFastScan
     |  implementations.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_QueryFactorsData(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  c1
     |
     |  c2
     |
     |  c34
     |
     |  g_error
     |
     |  int_dot_scale
     |
     |  q_dot_c
     |
     |  qr_norm_L2sqr
     |
     |  qr_to_c_L2sqr
     |
     |  rotated_q
     |
     |  thisown
     |      The membership flag

    class RaBitQDistanceComputer(FlatCodesDistanceComputer)
     |  RaBitQDistanceComputer(*args, **kwargs)
     |
     |  Method resolution order:
     |      RaBitQDistanceComputer
     |      FlatCodesDistanceComputer
     |      DistanceComputer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  distance_to_code(self, code)
     |      compute distance of current query to an encoded vector
     |
     |  distance_to_code_1bit(self, code)
     |
     |  distance_to_code_full(self, code)
     |
     |  symmetric_dis(self, arg2, arg3)
     |      compute distance between two stored vectors
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RaBitQDistanceComputer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centroid
     |
     |  d
     |
     |  g_error
     |
     |  metric_type
     |
     |  nb_bits
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from FlatCodesDistanceComputer:
     |
     |  __call__(self, i)
     |      compute distance of vector i to current query
     |
     |  partial_dot_product(self, arg2, arg3, arg4)
     |      Computes a partial dot product over a slice of the query vector.
     |      The slice is defined by the following parameters:
     |        — `offset`: the starting index of the first component to include
     |        — `num_components`: the number of consecutive components to include
     |
     |      Components refer to raw dimensions of the flat (uncompressed) query
     |      vector.
     |
     |      By default, this method throws an error, as it is only implemented
     |      in specific subclasses such as `FlatL2Dis`. Other flat distance
     |      computers may override this when partial dot product support is needed.
     |
     |      Over time, this method might be changed to a pure virtual function (`=
     |      0`) to enforce implementation in subclasses that require this
     |      functionality.
     |
     |      This method is not part of the generic `DistanceComputer` interface
     |      because for compressed representations (e.g., product quantization),
     |      calling `partial_dot_product` repeatedly is often less efficient than
     |      computing the full distance at once.
     |
     |      Supporting efficient partial scans generally requires a different memory
     |      layout, such as interleaved blocks that keep SIMD lanes full. This is a
     |      non-trivial change and not supported in the current flat layout.
     |
     |      For more details on partial (or chunked) dot product computations and
     |      the performance trade-offs involved, refer to the Panorama paper:
     |      https://arxiv.org/pdf/2510.00566
     |
     |  partial_dot_product_batch_4(self, idx0, idx1, idx2, idx3, dp0, dp1, dp2, dp3, offset, num_components)
     |      Compute partial dot products of current query to 4 stored vectors.
     |      See `partial_dot_product` for more details.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from FlatCodesDistanceComputer:
     |
     |  code_size
     |
     |  codes
     |
     |  q
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from DistanceComputer:
     |
     |  distances_batch_4(self, idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3)
     |      compute distances of current query to 4 stored vectors.
     |      certain DistanceComputer implementations may benefit
     |      heavily from this.
     |
     |  set_query(self, x)
     |      called before computing distances. Pointer x should remain valid
     |      while operator () is called
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from DistanceComputer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class RaBitQSearchParameters(SearchParameters)
     |  RaBitQSearchParameters(**args)
     |
     |  Method resolution order:
     |      RaBitQSearchParameters
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RaBitQSearchParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centered
     |
     |  qb
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class RaBitQuantizer(Quantizer)
     |  RaBitQuantizer(*args)
     |
     |  Method resolution order:
     |      RaBitQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_code_size(self, d, num_bits)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  compute_codes_core(self, x, codes, n, centroid_in)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, codes, x, n)
     |
     |  decode_core(self, codes, x, n, centroid_in)
     |
     |  get_distance_computer(self, qb=0, centroid=None, centered=False)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RaBitQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  centroid
     |
     |  metric_type
     |
     |  nb_bits
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class RandomGenerator(builtins.object)
     |  RandomGenerator(seed=1234)
     |
     |  random generator that can be used in multithreaded contexts
     |
     |  Methods defined here:
     |
     |  __init__(self, seed=1234)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  rand_double(self)
     |
     |  rand_float(self)
     |      between 0 and 1
     |
     |  rand_int(self, *args)
     |      *Overload 1:*
     |      random positive integer
     |
     |      |
     |
     |      *Overload 2:*
     |      generate random integer between 0 and max-1
     |
     |  rand_int64(self)
     |      random int64_t
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RandomGenerator(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  mt
     |
     |  thisown
     |      The membership flag

    class RandomRotationMatrix(LinearTransform)
     |  RandomRotationMatrix(*args)
     |
     |  Randomly rotate a set of vectors
     |
     |  Method resolution order:
     |      RandomRotationMatrix
     |      LinearTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      both d_in > d_out and d_out < d_in are supported
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  init(self, seed)
     |      must be called before the transform is used
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RandomRotationMatrix(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from LinearTransform:
     |
     |  apply_noalloc(self, n, x, xt)
     |      same as apply, but result is pre-allocated
     |
     |  check_identical(self, other)
     |
     |  print_if_verbose(self, name, mat, n, d)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      works only if is_orthonormal
     |
     |  set_is_orthonormal(self)
     |      compute A^T * A to set the is_orthonormal flag
     |
     |  transform_transpose(self, n, y, x)
     |      compute x = A^T * (x - b)
     |      is reverse transform if A has orthonormal lines
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from LinearTransform:
     |
     |  A
     |      Transformation matrix, size d_out * d_in
     |
     |  b
     |      bias vector, size d_out
     |
     |  have_bias
     |
     |  is_orthonormal
     |      whether to use the bias term
     |       check if matrix A is orthonormal (enables reverse_transform)
     |
     |  verbose
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class RangeQueryResult(builtins.object)
     |  result structure for a single query
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add(self, dis, id)
     |      called by search function to report a new result
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RangeQueryResult(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  nres
     |
     |  pres
     |
     |  qno
     |
     |  stats
     |
     |  thisown
     |      The membership flag

    class RangeSearchPartialResult(BufferList)
     |  RangeSearchPartialResult(res_in)
     |
     |  the entries in the buffers are split per query
     |
     |  Method resolution order:
     |      RangeSearchPartialResult
     |      BufferList
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, res_in)
     |      eventually the result will be stored in res_in
     |
     |  __repr__ = _swig_repr(self)
     |
     |  copy_result(self, incremental=False)
     |      called by range_search after do_allocation
     |
     |  finalize(self)
     |
     |  new_result(self, qno)
     |      begin a new result
     |
     |  set_lims(self)
     |      called by range_search before do_allocation
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RangeSearchPartialResult(...)
     |
     |  merge(partial_results, do_delete=True)
     |      merge a set of PartialResult's into one RangeSearchResult
     |      on output the partialresults are empty!
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  queries
     |      query ids + nb of results per query.
     |
     |  res
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from BufferList:
     |
     |  add(self, id, dis)
     |      add one result, possibly appending a new buffer if needed
     |
     |  append_buffer(self)
     |      create a new buffer
     |
     |  copy_range(self, ofs, n, dest_ids, dest_dis)
     |      copy elements ofs:ofs+n-1 seen as linear data in the buffers to
     |      tables dest_ids, dest_dis
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from BufferList:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  buffer_size
     |
     |  buffers
     |
     |  wp
     |      write pointer in the last buffer.

    class RangeSearchResult(builtins.object)
     |  RangeSearchResult(nq, alloc_lims=True)
     |
     |  The objective is to have a simple result structure while
     |  minimizing the number of mem copies in the result. The method
     |  do_allocation can be overloaded to allocate the result tables in
     |  the matrix type of a scripting language like Lua or Python.
     |
     |  Methods defined here:
     |
     |  __init__(self, nq, alloc_lims=True)
     |      lims must be allocated on input to range_search.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  do_allocation(self)
     |      called when lims contains the nb of elements result entries
     |      for each query
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RangeSearchResult(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  buffer_size
     |      size of the result buffers used
     |
     |  distances
     |      corresponding distances (not sorted)
     |
     |  labels
     |      result for query i is labels[lims[i]:lims[i+1]]
     |
     |  lims
     |      size (nq + 1)
     |
     |  nq
     |      nb of queries
     |
     |  thisown
     |      The membership flag

    class ReadOnlyInvertedLists(InvertedLists)
     |  ReadOnlyInvertedLists(*args, **kwargs)
     |
     |  invlists that fail for all write functions
     |
     |  Method resolution order:
     |      ReadOnlyInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ReadOnlyInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class RefineBeamLUTMemoryPool(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RefineBeamLUTMemoryPool(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  codes
     |
     |  distances
     |
     |  new_codes
     |
     |  new_distances
     |
     |  thisown
     |      The membership flag

    class RefineBeamMemoryPool(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RefineBeamMemoryPool(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  codes
     |
     |  distances
     |
     |  new_codes
     |
     |  new_residuals
     |
     |  residuals
     |
     |  thisown
     |      The membership flag

    class RemapDimensionsTransform(VectorTransform)
     |  RemapDimensionsTransform(*args)
     |
     |   remap dimensions for input vectors, possibly inserting 0s
     |  strictly speaking this is also a linear transform but we don't want
     |  to compute it with matrix multiplies
     |
     |  Method resolution order:
     |      RemapDimensionsTransform
     |      VectorTransform
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      *Overload 1:*
     |      remap input to output, skipping or inserting dimensions as needed
     |      if uniform: distribute dimensions uniformly
     |      otherwise just take the d_out first ones.
     |
     |      |
     |
     |      *Overload 2:*
     |      remap input to output, skipping or inserting dimensions as needed
     |      if uniform: distribute dimensions uniformly
     |      otherwise just take the d_out first ones.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |       apply the transformation and return the result in a provided matrix
     |      :type n: int
     |      :param n: number of vectors to transform
     |      :type x: float
     |      :param x: input vectors, size n * d_in
     |      :type xt: float
     |      :param xt: output vectors, size n * d_out
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      reverse transform correct only when the mapping is a permutation
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x) from VectorTransform
     |       Perform training on a representative set of vectors. Does
     |      nothing by default.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RemapDimensionsTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  map
     |      map from output dimension to input, size d_out
     |      -1 -> set output to 0
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VectorTransform:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already

    class Repeat(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Repeat(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n
     |
     |  thisown
     |      The membership flag
     |
     |  val

    class RepeatVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_RepeatVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class Repeats(builtins.object)
     |  Repeats(dim_in=0, c=None)
     |
     |  Repeats: used to encode a vector that has n occurrences of
     |  val. Encodes the signs and permutation of the vector. Useful for
     |  atoms.
     |
     |  Methods defined here:
     |
     |  __init__(self, dim_in=0, c=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  count(self)
     |
     |  decode(self, code, c)
     |
     |  encode(self, c)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Repeats(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dim
     |
     |  repeats
     |
     |  thisown
     |      The membership flag

    class ReproduceDistancesObjective(PermutationObjective)
     |  ReproduceDistancesObjective(n_in, source_dis_in, target_dis_in, dis_weight_factor_in)
     |
     |  Method resolution order:
     |      ReproduceDistancesObjective
     |      PermutationObjective
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, n_in, source_dis_in, target_dis_in, dis_weight_factor_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_cost(self, perm)
     |
     |  cost_update(self, perm, iw, jw)
     |
     |  dis_weight(self, x)
     |
     |  get_source_dis(self, i, j)
     |
     |  set_affine_target_dis(self, source_dis_in)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ReproduceDistancesObjective(...)
     |
     |  compute_mean_stdev(tab, n2, mean_out, stddev_out)
     |
     |  sqr(x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  dis_weight_factor
     |
     |  source_dis
     |      "real" corrected distances (size n^2)
     |
     |  target_dis
     |      wanted distances (size n^2)
     |
     |  thisown
     |      The membership flag
     |
     |  weights
     |      weights for each distance (size n^2)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from PermutationObjective:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  n

    class ResidualCoarseQuantizer(AdditiveCoarseQuantizer)
     |  ResidualCoarseQuantizer(*args)
     |
     |   The ResidualCoarseQuantizer is a bit specialized compared to the
     |  default AdditiveCoarseQuantizer because it can use a beam search
     |  at search time (slow but may be useful for very large vocabularies)
     |
     |  Method resolution order:
     |      ResidualCoarseQuantizer
     |      AdditiveCoarseQuantizer
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args)
     |       Constructor.
     |
     |      :type d: int
     |      :param d:      dimensionality of the input vectors
     |      :type M: int
     |      :param M:      number of subquantizers
     |      :type nbits: int
     |      :param nbits:  number of bit per subvector index
     |
     |      :type d: int
     |      :param d: dimensionality of the input vectors
     |      :type M: int
     |      :param M: number of subquantizers
     |      :type nbits: int
     |      :param nbits: number of bit per subvector index
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  initialize_from(self, other)
     |       Copy the M first codebook levels from other. Useful to crop a
     |      ResidualQuantizer to its first M quantizers.
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |
     |  set_beam_factor(self, new_beam_factor)
     |      computes centroid norms if required
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ResidualCoarseQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  beam_factor
     |      factor between the beam size and the search k
     |      if negative, use exact search-to-centroid
     |
     |  rq
     |      The residual quantizer used to encode the vectors
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveCoarseQuantizer:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |      N/A
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids) from Index
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids) from Index
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1) from Index
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None) from Index
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons) from Index
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons) from Index
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel) from Index
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  reset(self)
     |      N/A
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x) from Index
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes) from Index
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None) from Index
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveCoarseQuantizer:
     |
     |  aq
     |
     |  centroid_norms
     |      norms of centroids, useful for knn-search
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class ResidualQuantizer(AdditiveQuantizer)
     |  ResidualQuantizer(*args)
     |
     |   Residual quantizer with variable number of bits per sub-quantizer
     |
     |  The residual centroids are stored in a big cumulative centroid table.
     |  The codes are represented either as a non-compact table of size (n, M) or
     |  as the compact output (n, code_size).
     |
     |  Method resolution order:
     |      ResidualQuantizer
     |      AdditiveQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_codes_add_centroids(self, x, codes, n, centroids=None)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |      :type centroids: float, optional
     |      :param centroids:  centroids to be added to x, size n * d
     |
     |  initialize_from(self, other, skip_M=0)
     |      Copy the M codebook levels from other, starting from skip_M
     |
     |  memory_per_point(self, beam_size=-1)
     |       Beam search can consume a lot of memory. This function estimates the
     |      amount of mem used by refine_beam to adjust the batch size
     |
     |      :type beam_size: int, optional
     |      :param beam_size:  if != -1, override the beam size
     |
     |  refine_beam(self, n, beam_size, residuals, new_beam_size, new_codes, new_residuals=None, new_distances=None)
     |       lower-level encode function
     |
     |      :type n: int
     |      :param n:              number of vectors to handle
     |      :type residuals: float
     |      :param residuals:      vectors to encode, size (n, beam_size, d)
     |      :type beam_size: int
     |      :param beam_size:      input beam size
     |      :type new_beam_size: int
     |      :param new_beam_size:  output beam size (should be <= K * beam_size)
     |      :type new_codes: int
     |      :param new_codes:      output codes, size (n, new_beam_size, m + 1)
     |      :type new_residuals: float, optional
     |      :param new_residuals:  output residuals, size (n, new_beam_size, d)
     |      :type new_distances: float, optional
     |      :param new_distances:  output distances, size (n, new_beam_size)
     |
     |  refine_beam_LUT(self, n, query_norms, query_cp, new_beam_size, new_codes, new_distances=None)
     |
     |  retrain_AQ_codebook(self, n, x)
     |       Encode the vectors and compute codebook that minimizes the quantization
     |      error on these codes
     |
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |      :type n: int
     |      :param n:      nb of training vectors, n >= total_codebook_size
     |      :rtype: float
     |      :return: returns quantization error for the new codebook with old
     |          codes
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Train the residual quantizer
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ResidualQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  approx_topk_mode
     |      Currently used mode of approximate min-k computations.
     |      Default value is EXACT_TOPK.
     |
     |  assign_index_factory
     |      if non-NULL, use this index for assignment
     |
     |  cp
     |      clustering parameters
     |
     |  max_beam_size
     |      beam size used for training and for encoding
     |
     |  niter_codebook_refine
     |      number of iterations for codebook refinement.
     |
     |  thisown
     |      The membership flag
     |
     |  train_type
     |      Binary or of the Train_* flags below
     |
     |  use_beam_LUT
     |      use LUT for beam search
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  Skip_codebook_tables = 2048
     |
     |  Train_default = 0
     |
     |  Train_progressive_dim = 1
     |
     |  Train_refine_codebook = 2
     |
     |  Train_top_beam = 1024
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AdditiveQuantizer:
     |
     |  compute_LUT(self, n, xq, LUT, alpha=1.0, ld_lut=-1)
     |       Compute inner-product look-up tables. Used in the centroid search
     |      functions.
     |
     |      :type xq: float
     |      :param xq:     query vector, size (n, d)
     |      :type LUT: float
     |      :param LUT:    look-up table, size (n, total_codebook_size)
     |      :type alpha: float, optional
     |      :param alpha:  compute alpha * inner-product
     |      :type ld_lut: int, optional
     |      :param ld_lut:  leading dimension of LUT
     |
     |  compute_centroid_norms(self, norms)
     |       For L2 search we need the L2 norms of the centroids
     |
     |      :type norms: float
     |      :param norms:    output norms table, size total_codebook_size
     |
     |  compute_codebook_tables(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_64bit(self, n, x)
     |      decoding function for a code in a 64-bit word
     |
     |  decode_c = decode(self, codes, x, n)
     |       Decode a set of vectors
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  decode_qcint(self, c)
     |      decode norm by non-uniform scalar quantization
     |
     |  decode_unpacked(self, codes, x, n, ld_codes=-1)
     |       Decode a set of vectors in non-packed format
     |
     |      :type codes: int
     |      :param codes:  codes to decode, size n * ld_codes
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  encode_norm(self, norm)
     |      encode a norm into norm_bits bits
     |
     |  encode_qcint(self, x)
     |      encode norm by non-uniform scalar quantization
     |
     |  knn_centroids_L2(self, n, xq, k, distances, labels, centroid_norms)
     |      Exact L2 search, with precomputed norms
     |
     |  knn_centroids_inner_product(self, n, xq, k, distances, labels)
     |      exact IP search
     |
     |  pack_codes(self, n, codes, packed_codes, ld_codes=-1, norms=None, centroids=None)
     |       pack a series of code to bit-compact format
     |
     |      :type codes: int
     |      :param codes:        codes to be packed, size n * code_size
     |      :type packed_codes: uint8_t
     |      :param packed_codes: output bit-compact codes
     |      :type ld_codes: int, optional
     |      :param ld_codes:     leading dimension of codes
     |      :type norms: float, optional
     |      :param norms:        norms of the vectors (size n). Will be computed if
     |                              needed but not provided
     |      :type centroids: float, optional
     |      :param centroids:    centroids to be added to x, size n * d
     |
     |  set_derived_values(self)
     |      Train the norm quantizer
     |
     |  train_norm(self, n, norms)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AdditiveQuantizer:
     |
     |  M
     |      number of codebooks
     |
     |  centroid_norms
     |      norms of all codebook entries (size total_codebook_size)
     |
     |  codebook_cross_products
     |      dot products of all codebook entries with the previous codebooks
     |      size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1)
     |
     |  codebook_offsets
     |      codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1]
     |      in the codebooks table of size total_codebook_size by d
     |
     |  codebooks
     |      codebooks
     |
     |  is_trained
     |      is trained or not
     |
     |  max_mem_distances
     |      norms and distance matrixes with beam search can get large, so use this
     |      to control for the amount of memory that can be allocated
     |
     |  nbits
     |      bits for each step
     |
     |  norm_bits
     |      bits allocated for the norms
     |
     |  norm_max
     |
     |  norm_min
     |      min/max for quantization of norms
     |
     |  norm_tabs
     |      auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4
     |      store norms of codebook entries for 4-bit fastscan
     |
     |  only_8bit
     |      are all nbits = 8 (use faster decoder)
     |
     |  qnorm
     |      store and search norms
     |
     |  search_type
     |      Also determines what's in the codes
     |
     |  tot_bits
     |      total number of bits (indexes + norms)
     |
     |  total_codebook_size
     |      size of the codebook in vectors
     |
     |  verbose
     |      verbose during training?
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AdditiveQuantizer:
     |
     |  ST_LUT_nonorm = 1
     |
     |  ST_count = 10
     |
     |  ST_decompress = 0
     |
     |  ST_norm_cqint4 = 7
     |
     |  ST_norm_cqint8 = 6
     |
     |  ST_norm_float = 3
     |
     |  ST_norm_from_LUT = 2
     |
     |  ST_norm_lsq2x4 = 8
     |
     |  ST_norm_qint4 = 5
     |
     |  ST_norm_qint8 = 4
     |
     |  ST_norm_rq2x4 = 9
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class SIMDConfig(builtins.object)
     |  SIMDConfig(faiss_simd_level_env=None)
     |
     |  Current SIMD configuration.
     |
     |  This class provides a uniform API for querying and setting the SIMD level,
     |  regardless of whether faiss was built with Dynamic Dispatch (DD) or static
     |  SIMD selection.
     |
     |  In DD mode:
     |    - get_level() returns the runtime-detected or user-set level
     |    - set_level() changes the runtime level (if level is supported)
     |    - supported_simd_levels() returns bitmask of all compiled-in levels
     |
     |  In static mode:
     |    - get_level() returns the compiled-in level
     |    - set_level() succeeds only if level matches compiled-in level
     |    - supported_simd_levels() returns bitmask with single level
     |
     |  Methods defined here:
     |
     |  __init__(self, faiss_simd_level_env=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SIMDConfig(...)
     |
     |  auto_detect_simd_level()
     |
     |  get_dispatched_level()
     |      Returns the SIMD level via the dispatch mechanism.
     |      In DD mode, uses with_simd_level internally.
     |      In static mode, returns the compiled-in level.
     |      Useful for verification: get_level() == get_dispatched_level()
     |
     |  get_level()
     |
     |  get_level_name()
     |
     |  is_simd_level_available(level)
     |      Check if a SIMD level is available (compiled in).
     |
     |  set_level(level)
     |      Set the SIMD level. Throws FaissException if level is not supported.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  level
     |
     |  supported_simd_levels
     |      Returns bitmask of supported SIMD levels (1 << SIMDLevel).
     |
     |  thisown
     |      The membership flag

    class ScalarQuantizer(Quantizer)
     |  ScalarQuantizer(*args)
     |
     |  The uniform quantizer has a range [vmin, vmax]. The range can be
     |  the same for all dimensions (uniform) or specific per dimension
     |  (default).
     |
     |  Method resolution order:
     |      ScalarQuantizer
     |      Quantizer
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  compute_codes = replacement_compute_codes(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Compute the codes corresponding to a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Vectors to encode, shape (n, self.d). `dtype` must be float32.
     |
     |      Returns
     |      -------
     |      codes : array_like
     |          Corresponding code for each vector, shape (n, self.code_size)
     |          and `dtype` uint8.
     |
     |  compute_codes_c = compute_codes(self, x, codes, n)
     |       Encode a set of vectors
     |
     |      :type x: float
     |      :param x:      vectors to encode, size n * d
     |      :type codes: uint8_t
     |      :param codes:  output codes, size n * code_size
     |
     |  decode = replacement_decode(self, codes) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Reconstruct an approximation of vectors given their codes.
     |
     |      Parameters
     |      ----------
     |      codes : array_like
     |          Codes to decode, shape (n, self.code_size). `dtype` must be uint8.
     |
     |      Returns
     |      -------
     |          Reconstructed vectors for each code, shape `(n, d)` and `dtype` float32.
     |
     |  decode_c = decode(self, code, x, n)
     |       Decode a set of vectors
     |
     |      :param codes:  codes to decode, size n * code_size
     |      :type x: float
     |      :param x:      output vectors, size n * d
     |
     |  get_distance_computer(self, *args)
     |
     |  select_InvertedListScanner(self, mt, quantizer, store_pairs, sel, by_residual=False)
     |
     |  select_quantizer(self)
     |
     |  set_derived_sizes(self)
     |      updates internal values based on qtype and d
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_Quantizer.<locals>
     |      Train the quantizer on a set of training vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ScalarQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  bits
     |      bits per scalar code
     |
     |  qtype
     |
     |  rangestat
     |
     |  rangestat_arg
     |
     |  thisown
     |      The membership flag
     |
     |  trained
     |      trained values (including the range)
     |
     |  turboq_refine
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  QT_0bit = 9
     |
     |  QT_1bit_tqmse = 10
     |
     |  QT_2bit_tq = 15
     |
     |  QT_2bit_tqmse = 11
     |
     |  QT_3bit_tq = 16
     |
     |  QT_3bit_tqmse = 12
     |
     |  QT_4bit = 1
     |
     |  QT_4bit_tq = 17
     |
     |  QT_4bit_tqmse = 13
     |
     |  QT_4bit_uniform = 3
     |
     |  QT_5bit_tq = 18
     |
     |  QT_6bit = 6
     |
     |  QT_8bit = 0
     |
     |  QT_8bit_direct = 5
     |
     |  QT_8bit_direct_signed = 8
     |
     |  QT_8bit_tqmse = 14
     |
     |  QT_8bit_uniform = 2
     |
     |  QT_bf16 = 7
     |
     |  QT_count = 19
     |
     |  QT_fp16 = 4
     |
     |  RS_meanstd = 1
     |
     |  RS_minmax = 0
     |
     |  RS_optim = 3
     |
     |  RS_quantiles = 2
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Quantizer:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      bytes per indexed vector
     |
     |  d
     |      size of the input vectors

    class SearchParameters(builtins.object)
     |  SearchParameters(**args)
     |
     |   Parent class for the optional search parameters.
     |
     |  Sub-classes with additional search parameters should inherit this class.
     |  Ownership of the object fields is always to the caller.
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SearchParameters(...)
     |      make sure we can dynamic_cast this
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.
     |
     |  thisown
     |      The membership flag

    class SearchParametersHNSW(SearchParameters)
     |  SearchParametersHNSW(**args)
     |
     |  Method resolution order:
     |      SearchParametersHNSW
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SearchParametersHNSW(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  bounded_queue
     |
     |  check_relative_distance
     |
     |  efSearch
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SearchParameters:
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class SearchParametersIVF(SearchParameters)
     |  SearchParametersIVF(**args)
     |
     |  Method resolution order:
     |      SearchParametersIVF
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SearchParametersIVF(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  ensure_topk_full
     |      For k-NN search, make small early-stop budgets less aggressive:
     |      max_codes is treated as at least k post-IDSelector scans. Supported
     |      by generic IVF in parallel_mode 0 and 3, and by FastScan k-NN
     |      implementations 10 and 11.
     |
     |  inverted_list_context
     |      context object to pass to InvertedLists
     |
     |  max_codes
     |      max nb of codes to visit to do a query
     |
     |  max_empty_result_buckets
     |      Range-search only: stop after this many consecutive probed lists add
     |      no in-radius results. 0 disables the heuristic. This trades recall
     |      for less work. Supported in parallel_mode 0; FastScan range search
     |      uses implementation 10 for this option.
     |
     |  max_lists_num
     |      FastScan k-NN only: maximum number of inverted lists to visit.
     |      0 means unlimited, i.e. bounded only by nprobe. When set together
     |      with max_codes, either budget may stop the scan. With
     |      ensure_topk_full, this limit is treated as at least k lists.
     |
     |  nprobe
     |      number of probes at query time
     |
     |  quantizer_params
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SearchParameters:
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class SearchParametersPQ(SearchParameters)
     |  SearchParametersPQ(**args)
     |
     |  override search parameters from the class
     |
     |  Method resolution order:
     |      SearchParametersPQ
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SearchParametersPQ(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  polysemous_ht
     |
     |  search_type
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SearchParameters:
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class SearchParametersPreTransform(SearchParameters)
     |  SearchParametersPreTransform(**args)
     |
     |  Method resolution order:
     |      SearchParametersPreTransform
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SearchParametersPreTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  index_params
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SearchParameters:
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class SearchParametersResidualCoarseQuantizer(SearchParameters)
     |  SearchParametersResidualCoarseQuantizer(**args)
     |
     |  Method resolution order:
     |      SearchParametersResidualCoarseQuantizer
     |      SearchParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = replacement_init(self, **args) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  original_init = __init__(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SearchParametersResidualCoarseQuantizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  beam_factor
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SearchParameters:
     |
     |  __setattr__ = replacement_setattr(self, k, v) from faiss.class_wrappers.handle_SearchParameters.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SearchParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  sel
     |      if non-null, only these IDs will be considered during search.

    class ShardingFunction(builtins.object)
     |  ShardingFunction(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __call__(self, i, shard_count)
     |      Call self as a function.
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ShardingFunction(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class SignBitFactors(builtins.object)
     |   Base factors computed per database vector for RaBitQ distance computation.
     |  Used by both 1-bit and multi-bit RaBitQ variants.
     |  These can be stored either embedded in codes (IndexRaBitQ) or separately
     |  (IndexRaBitQFastScan).
     |
     |  For 1-bit mode only - contains the minimal factors needed for distance
     |  estimation using just sign bits.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SignBitFactors(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dp_multiplier
     |
     |  or_minus_c_l2sqr
     |
     |  thisown
     |      The membership flag

    class SignBitFactorsWithError(SignBitFactors)
     |   Extended factors for multi-bit RaBitQ (nb_bits > 1).
     |  Includes error bound for lower bound computation in two-stage search.
     |  Inherits base factors to maintain layout compatibility.
     |
     |  Used in multi-bit mode - the error bound enables quick filtering of
     |  unlikely candidates in the first stage of two-stage search.
     |
     |  Method resolution order:
     |      SignBitFactorsWithError
     |      SignBitFactors
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SignBitFactorsWithError(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  f_error
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SignBitFactors:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dp_multiplier
     |
     |  or_minus_c_l2sqr

    class SimulatedAnnealingOptimizer(SimulatedAnnealingParameters)
     |  SimulatedAnnealingOptimizer(obj_in, p)
     |
     |  Simulated annealing optimization algorithm for permutations.
     |
     |  Method resolution order:
     |      SimulatedAnnealingOptimizer
     |      SimulatedAnnealingParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, obj_in, p)
     |      logs values of the cost function
     |
     |  __repr__ = _swig_repr(self)
     |
     |  optimize(self, perm)
     |
     |  run_optimization(self, best_perm)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SimulatedAnnealingOptimizer(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  init_cost
     |      remember initial cost of optimization
     |
     |  logfile
     |
     |  n
     |      size of the permutation
     |
     |  obj
     |
     |  rnd
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SimulatedAnnealingParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  init_random
     |
     |  init_temperature
     |
     |  n_iter
     |
     |  n_redo
     |
     |  only_bit_flips
     |
     |  seed
     |
     |  temperature_decay
     |
     |  verbose

    class SimulatedAnnealingParameters(builtins.object)
     |  parameters used for the simulated annealing method
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SimulatedAnnealingParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  init_random
     |
     |  init_temperature
     |
     |  n_iter
     |
     |  n_redo
     |
     |  only_bit_flips
     |
     |  seed
     |
     |  temperature_decay
     |
     |  thisown
     |      The membership flag
     |
     |  verbose

    class SliceInvertedLists(ReadOnlyInvertedLists)
     |  SliceInvertedLists(il_, i0_, i1_)
     |
     |  vertical slice of indexes in another InvertedLists
     |
     |  Method resolution order:
     |      SliceInvertedLists
     |      ReadOnlyInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, il_, i0_, i1_)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SliceInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  i0
     |
     |  i1
     |
     |  il
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ReadOnlyInvertedLists:
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class SlidingIndexWindow(builtins.object)
     |  SlidingIndexWindow(index)
     |
     |   A set of IndexIVFs concatenated together in a FIFO fashion.
     |  at each "step", the oldest index slice is removed and a new index is added.
     |
     |  Methods defined here:
     |
     |  __init__(self, index)
     |      index should be initially empty and trained
     |
     |  __repr__ = _swig_repr(self)
     |
     |  step(self, sub_index, remove_oldest)
     |       Add one index to the current index and remove the oldest one.
     |
     |      :type sub_index: :py:class:`Index`
     |      :param sub_index:        slice to swap in (can be NULL)
     |      :type remove_oldest: boolean
     |      :param remove_oldest:    if true, remove the oldest slices
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SlidingIndexWindow(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ils
     |      InvertedLists of index
     |
     |  index
     |      common index that contains the sliding window
     |
     |  n_slice
     |      number of slices currently in index
     |
     |  nlist
     |      same as index->nlist
     |
     |  sizes
     |      cumulative list sizes at each slice
     |
     |  thisown
     |      The membership flag

    class SplitMix64RandomGenerator(builtins.object)
     |  SplitMix64RandomGenerator(seed=1234)
     |
     |  fast random generator that cannot be used in multithreaded contexts.
     |  based on https://prng.di.unimi.it/
     |
     |  Methods defined here:
     |
     |  __init__(self, seed=1234)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  next(self)
     |
     |  rand_double(self)
     |
     |  rand_float(self)
     |      between 0 and 1
     |
     |  rand_int(self, *args)
     |      *Overload 1:*
     |      random positive integer
     |
     |      |
     |
     |      *Overload 2:*
     |      generate random integer between 0 and max-1
     |
     |  rand_int64(self)
     |      random int64_t
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SplitMix64RandomGenerator(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  state
     |
     |  thisown
     |      The membership flag

    class StopWordsInvertedLists(ReadOnlyInvertedLists)
     |  StopWordsInvertedLists(il0_in, maxsize_in)
     |
     |  if the inverted list in il is smaller than maxsize then return it,
     |  otherwise return an empty invlist
     |
     |  Method resolution order:
     |      StopWordsInvertedLists
     |      ReadOnlyInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, il0_in, maxsize_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_StopWordsInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  il0
     |
     |  maxsize
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ReadOnlyInvertedLists:
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class SuperKMeans(builtins.object)
     |  SuperKMeans(*args)
     |
     |   Drop-in faster k-means: same interface as faiss::Clustering. Per iteration:
     |    iter 0:           full GEMM over all d dims (vanilla Lloyd's).
     |    iter 1..niter-1:  GEMM over front d_prime dims, then ADSampling
     |                      progressive pruning over PDX-laid trailing dims.
     |
     |  Trains in a randomly-rotated space; centroids are un-rotated before return.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_SuperKMeans.<locals>
     |      Perform SuperKMeans clustering on a set of vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Training vectors, shape (n, self.d). `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |      Train on `n` row-major vectors of dimension `d`. Honors the applicable
     |      ClusteringParameters fields (niter, seed, verbose,
     |      max_points_per_centroid, use_faster_subsampling,
     |      check_input_data_for_NaNs).
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SuperKMeans(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  centroids
     |      Output: k * d floats, row-major, un-rotated.
     |
     |  cp
     |
     |  d
     |
     |  gemm_pruning_rates
     |      Per-iter fraction of (vector, centroid) pairs pruned at the d_prime
     |      GEMM-boundary chi-squared check. Per-PDX-block early-exits are NOT
     |      counted. iter 0 uses full GEMM, so gemm_pruning_rates[0] == 0.0f.
     |
     |  iteration_stats
     |      Per-iter stats. `obj`, `time`, and `nsplit` are populated faithfully.
     |      `time_search` mirrors `time` (phases not timed separately) and
     |      `imbalance_factor` is set to NaN (not computed).
     |
     |  k
     |
     |  thisown
     |      The membership flag

    class SuperKMeansParameters(ClusteringParameters)
     |  Method resolution order:
     |      SuperKMeansParameters
     |      ClusteringParameters
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SuperKMeansParameters(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  ad_epsilon_factor
     |      ADSampling significance: epsilon = ad_epsilon_factor / d.
     |
     |  d_prime_adjust
     |      Relative step size for d_prime adjustments.
     |
     |  d_prime_fraction
     |      Initial d_prime as a fraction of d (GEMM/PRUNING split).
     |
     |  d_prime_min
     |      Floor on d_prime; below this the chi-squared bound is unvalidated.
     |
     |  omp_chunk
     |      OpenMP dynamic-schedule chunk size for the pruning loop.
     |
     |  pdx_block_size
     |      Matches block_l2 SIMD width.
     |
     |  pruning_target_high
     |
     |  pruning_target_low
     |      Adaptive d_prime stay-in-band controller. Per iteration:
     |        pruning > high → shrink d_prime  (over-pruning, cheaper threshold)
     |        pruning < low  → grow   d_prime  (under-pruning, more GEMM work)
     |        else: hold.
     |
     |  thisown
     |      The membership flag
     |
     |  x_batch
     |
     |  y_batch
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ClusteringParameters:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  afkmc2_chain_length
     |      Chain length for AFK-MC² initialization.
     |      Only used when init_method = AFK_MC2.
     |      Longer chains give better approximation but are slower.
     |
     |  check_input_data_for_NaNs
     |      whether to check for NaNs in an input data
     |
     |  decode_block_size
     |      when the training set is encoded, batch size of the codec decoder
     |
     |  early_stop_threshold
     |      Early stop threshold, the range is [0, 1].
     |      The value of 0 implies a default Faiss behavior,
     |      so the training process stops only if an error
     |      is unchanged from the previous iteration.
     |
     |  frozen_centroids
     |      Use the subset of centroids provided as input and do not change them
     |      during iterations
     |
     |  init_method
     |      Initialization method for centroids.
     |      RANDOM: uniform random sampling (default, current behavior)
     |      KMEANS_PLUS_PLUS: k-means++ (O(nkd), better quality)
     |      AFK_MC2: Assumption-Free K-MC² (O(nd) + O(mk²d), fast approximation)
     |
     |  int_centroids
     |      round centroids coordinates to integer after each iteration?
     |
     |  max_points_per_centroid
     |      to limit size of dataset, otherwise the training set is subsampled
     |
     |  min_points_per_centroid
     |      If fewer than this number of training vectors per centroid are provided,
     |      writes a warning. Note that fewer than 1 point per centroid raises an
     |      exception.
     |
     |  niter
     |      number of clustering iterations
     |
     |  nredo
     |      redo clustering this many times and keep the clusters with the best
     |      objective
     |
     |  seed
     |      seed for the random number generator.
     |      negative values lead to seeding an internal rng with
     |      std::high_resolution_clock.
     |
     |  spherical
     |      whether to normalize centroids after each iteration (useful for inner
     |      product clustering)
     |
     |  update_index
     |      re-train index after each iteration?
     |
     |  use_faster_subsampling
     |      Whether to use splitmix64-based random number generator for subsampling,
     |      which is faster, but may pick duplicate points.
     |
     |  verbose

    class SwigPyIterator(builtins.object)
     |  SwigPyIterator(*args, **kwargs)
     |
     |  Methods defined here:
     |
     |  __add__(self, n)
     |
     |  __eq__(self, x)
     |      Return self==value.
     |
     |  __iadd__(self, n)
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __isub__(self, n)
     |
     |  __iter__(self)
     |
     |  __ne__(self, x)
     |      Return self!=value.
     |
     |  __next__(self)
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __sub__(self, *args)
     |
     |  advance(self, n)
     |
     |  copy(self)
     |
     |  decr(self, n=1)
     |
     |  distance(self, x)
     |
     |  equal(self, x)
     |
     |  incr(self, n=1)
     |
     |  next(self)
     |
     |  previous(self)
     |
     |  value(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_SwigPyIterator(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

    class Tensor2D(builtins.object)
     |  Tensor2D(*args)
     |
     |  Implements a few neural net layers, mainly to support QINCo
     |
     |  Methods defined here:
     |
     |  __iadd__(self, arg2)
     |
     |  __init__ = replacement_init(self, *args) from faiss.class_wrappers.handle_Tensor2D.<locals>
     |
     |  __repr__ = _swig_repr(self)
     |
     |  column(self, j)
     |      get column #j as a 1-column Tensor2D
     |
     |  data(self, *args)
     |
     |  numel(self)
     |
     |  numpy(self) from faiss.class_wrappers.handle_Tensor2D.<locals>
     |
     |  original_init = __init__(self, n0, n1, data=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_Tensor2D(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  shape
     |
     |  thisown
     |      The membership flag
     |
     |  v

    class ThreadedIndexBase(Index)
     |  ThreadedIndexBase(*args, **kwargs)
     |
     |  A holder of indices in a collection of threads
     |  The interface to this class itself is not thread safe
     |
     |  Method resolution order:
     |      ThreadedIndexBase
     |      Index
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __getstate__ = index_getstate(self) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  __setattr__ = replacement_setattr(self, name, value) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  __setstate__ = index_setstate(self, st) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  addIndex(self, index)
     |      override an index that is managed by ourselves.
     |      WARNING: once an index is added, it becomes unsafe to touch it from any
     |      other thread than that on which is managing it, until we are shut
     |      down. Use runOnIndex to perform work on it instead.
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ThreadedIndexBase(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Index:
     |
     |  add = replacement_add(self, x, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors to the index.
     |      The index must be trained before vectors can be added to it.
     |      The vectors are implicitly numbered in sequence. When `n` vectors are
     |      added to the index, they are given ids `ntotal`, `ntotal + 1`, ..., `ntotal + n - 1`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  add_c = add(self, n, x)
     |       Add n vectors of dimension d to the index.
     |
     |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
     |      This function slices the input vectors in chunks smaller than
     |      blocksize_add and calls add_core.
     |      :type n: int
     |      :param n:      number of vectors
     |      :type x: float
     |      :param x:      input matrix, size n * d
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes = replacement_add_sa_codes(self, codes, ids=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  add_sa_codes_c = add_sa_codes(self, n, codes, xids)
     |       Add vectors that are computed with the standalone codec
     |
     |      :type codes: uint8_t
     |      :param codes:  codes to add size n * sa_code_size()
     |      :type xids: int
     |      :param xids:   corresponding ids, size n
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Adds vectors with arbitrary ids to the index (not all indexes support this).
     |      The index must be trained before vectors can be added to it.
     |      Vector `i` is stored in `x[i]` and has id `ids[i]`.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      ids : array_like
     |          Array if ids of size n. The ids must be of type `int64`. Note that `-1` is reserved
     |          in result lists to mean "not found" so it's better to not use it as an id.
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:         number of vectors
     |      :type x: float
     |      :param x:         input vectors, size n * d
     |      :type xids: int
     |      :param xids:      if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical as search but only return labels of
     |      neighbors.
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type k: int, optional
     |      :param k:           number of nearest neighbours
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  compute_residual(self, x, residual, key)
     |       Computes a residual vector after indexing encoding.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type x: float
     |      :param x:           input vector, size d
     |      :type residual: float
     |      :param residual:    output residual vector, size d
     |      :type key: int
     |      :param key:         encoded index, as returned by search and assign
     |
     |  compute_residual_n(self, n, xs, residuals, keys)
     |       Computes a residual vector after indexing encoding (batch form).
     |      Equivalent to calling compute_residual for each vector.
     |
     |      The residual vector is the difference between a vector and the
     |      reconstruction that can be decoded from its representation in
     |      the index. The residual can be used for multiple-stage indexing
     |      methods, like IndexIVF's methods.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type xs: float
     |      :param xs:          input vectors, size (n x d)
     |      :type residuals: float
     |      :param residuals:   output residual vectors, size (n x d)
     |      :type keys: int
     |      :param keys:        encoded index, as returned by search and assign
     |
     |  get_distance_computer(self)
     |       Get a DistanceComputer (defined in AuxIndexStructures) object
     |      for this kind of index.
     |
     |      DistanceComputer is implemented for indexes that support random
     |      access of their vectors.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Search vectors that are within a distance of the query vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      thresh : float
     |          Threshold to select neighbors. All elements within this radius are returned,
     |          except for maximum inner product indexes, where the elements above the
     |          threshold are returned
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |
     |
     |      Returns
     |      -------
     |      lims: array_like
     |          Starting index of the results for each query vector, size n+1.
     |      D : array_like
     |          Distances of the nearest neighbors, shape `lims[n]`. The distances for
     |          query i are in `D[lims[i]:lims[i+1]]`.
     |      I : array_like
     |          Labels of nearest neighbors, shape `lims[n]`. The labels for query i
     |          are in `I[lims[i]:lims[i+1]]`.
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many
     |      indexes do not implement the range_search (only the k-NN search
     |      is mandatory).
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type radius: float
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of one vector from the index.
     |
     |      Parameters
     |      ----------
     |      key : int
     |          Id of the vector to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like reconstructed vector, size `self.d`, `dtype`=float32
     |
     |  reconstruct_batch = replacement_reconstruct_batch(self, key, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of several vectors from the index.
     |
     |      Parameters
     |      ----------
     |      key : array of ints
     |          Ids of the vectors to reconstruct
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          reconstrcuted vectors, size `len(key), self.d`
     |
     |  reconstruct_batch_c = reconstruct_batch(self, n, keys, recons)
     |       Reconstruct several stored vectors (or an approximation if lossy
     |      coding)
     |
     |      this function may not be defined for some indexes
     |      :type n: int
     |      :param n:           number of vectors to reconstruct
     |      :type keys: int
     |      :param keys:        ids of the vectors to reconstruct (size n)
     |      :type recons: float
     |      :param recons:      reconstructed vector (size n * d)
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector (or an approximation if lossy coding)
     |
     |      this function may not be defined for some indexes
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: float
     |      :param recons:      reconstructed vector (size d)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Approximate reconstruction of vectors `n0` ... `n0 + ni - 1` from the index.
     |      Missing vectors trigger an exception.
     |
     |      Parameters
     |      ----------
     |      n0 : int
     |          Id of the first vector to reconstruct (default 0)
     |      ni : int
     |          Number of vectors to reconstruct (-1 = default = ntotal)
     |      x : array_like, optional
     |          pre-allocated array to store the results
     |
     |      Returns
     |      -------
     |      x : array_like
     |          Reconstructed vectors, size (`ni`, `self.d`), `dtype`=float32
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1
     |
     |      this function may not be defined for some indexes
     |      :type i0: int
     |      :param i0:          index of the first vector in the sequence
     |      :type ni: int
     |      :param ni:          number of vectors in the sequence
     |      :type recons: float
     |      :param recons:      reconstructed vector (size ni * d)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_Index.<locals>
     |      Remove some ids from the index.
     |      This is a O(ntotal) operation by default, so could be expensive.
     |
     |      Parameters
     |      ----------
     |      x : array_like or faiss.IDSelector
     |          Either an IDSelector that returns True for vectors to remove, or a
     |          list of ids to reomove (1D array of int64). When `x` is a list,
     |          it is wrapped into an IDSelector.
     |
     |      Returns
     |      -------
     |      n_remove: int
     |          number of vectors that were removed
     |
     |  remove_ids_c = remove_ids(self, sel)
     |       removes IDs from the index. Not supported by all
     |      indexes. Returns the number of elements removed.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  sa_decode = replacement_sa_decode(self, codes, x=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_decode_c = sa_decode(self, n, bytes, x)
     |       decode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type bytes: uint8_t
     |      :param bytes:   input encoded vectors, size n * sa_code_size()
     |      :type x: float
     |      :param x:       output vectors, size n * d
     |
     |  sa_encode = replacement_sa_encode(self, x, codes=None) from faiss.class_wrappers.handle_Index.<locals>
     |
     |  sa_encode_c = sa_encode(self, n, x, bytes)
     |       encode a set of vectors
     |
     |      :type n: int
     |      :param n:       number of vectors
     |      :type x: float
     |      :param x:       input vectors, size n * d
     |      :type bytes: uint8_t
     |      :param bytes:   output encoded vectors, size n * sa_code_size()
     |
     |  search = replacement_search(self, x, k, *, params=None, D=None, I=None, numeric_type=0) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  search1(self, x, handler, params=None)
     |      search one vector with a custom result handler
     |
     |  search_and_reconstruct = replacement_search_and_reconstruct(self, x, k, *, params=None, D=None, I=None, R=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index,
     |      and return an approximation of these vectors.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be float32.
     |      k : int
     |          Number of nearest neighbors.
     |      params : SearchParameters
     |          Search parameters of the current search (overrides the class-level params)
     |      D : array_like, optional
     |          Distance array to store the result.
     |      I : array_like, optional
     |          Labels array to store the result.
     |      R : array_like, optional
     |          reconstruction array to store
     |
     |      Returns
     |      -------
     |      D : array_like
     |          Distances of the nearest neighbors, shape (n, k). When not enough results are found
     |          the label is set to +Inf or -Inf.
     |      I : array_like
     |          Labels of the nearest neighbors, shape (n, k). When not enough results are found,
     |          the label is set to -1
     |      R : array_like
     |          Approximate (reconstructed) nearest neighbor vectors, shape (n, k, d).
     |
     |  search_and_reconstruct_c = search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting arrays
     |      is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type recons: float
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       query n vectors of dimension d to the index.
     |
     |      return at most k vectors. If there are not enough results for a
     |      query, the result array is padded with -1s.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors to search, size n * d
     |      :type k: int
     |      :param k:           number of extracted vectors
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  search_subset(self, n, x, k_base, base_labels, k, distances, labels)
     |       Similar to search, but operates on a potentially different subset
     |      of the dataset for each query.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type n: int
     |      :param n:           number of vectors
     |      :type x: float
     |      :param x:           input vectors, size n * d
     |      :type k_base: int
     |      :param k_base:      number of vectors to search from
     |      :type base_labels: int
     |      :param base_labels: ids of the vectors to search from
     |      :type k: int
     |      :param k:           desired number of results per query
     |      :type distances: float
     |      :param distances:   output pairwise distances, size n*k
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  train = replacement_train(self, x, *, numeric_type=0, xq_train=None) from faiss.class_wrappers.handle_Index.<locals>
     |      Trains the index on a representative set of vectors.
     |      The index must be trained before vectors can be added to it.
     |      Optionally accepts numeric_type to specify the type of
     |      input vectors.
     |      Optionally accepts a set of training query vectors for
     |      out-of-distribution training.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate
     |          for the index. `dtype` must be float32.
     |      numeric_type : type
     |          Numeric type of the input vectors.
     |      xq_train : array_like, optional
     |          Training query vectors, shape (n_train_q, d) where
     |          d is appropriate for the index.
     |          `dtype` must be float32.
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  train_with_queries(self, n, x, n_train_q, xq_train)
     |       Perform training on a representative set of vectors and a representative
     |      set of queries
     |
     |      :type n: int
     |      :param n:         nb of training vectors
     |      :type x: float
     |      :param x:         training vectors, size n * d
     |      :type n_train_q: int
     |      :param n_train_q: nb of training queries
     |      :type xq_train: float
     |      :param xq_train:  training queries, size n_train_q * d
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Index:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is
     |      done already
     |
     |  metric_arg
     |      argument of the metric type
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class ThreadedIndexBaseBinary(IndexBinary)
     |  ThreadedIndexBaseBinary(*args, **kwargs)
     |
     |  A holder of indices in a collection of threads
     |  The interface to this class itself is not thread safe
     |
     |  Method resolution order:
     |      ThreadedIndexBaseBinary
     |      IndexBinary
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  addIndex(self, index)
     |      override an index that is managed by ourselves.
     |      WARNING: once an index is added, it becomes unsafe to touch it from any
     |      other thread than that on which is managing it, until we are shut
     |      down. Use runOnIndex to perform work on it instead.
     |
     |  at(self, *args)
     |      *Overload 1:*
     |      Returns the i-th sub-index
     |
     |      |
     |
     |      *Overload 2:*
     |      Returns the i-th sub-index (const version)
     |
     |  count(self)
     |      Returns the number of sub-indices
     |
     |  removeIndex(self, index)
     |      Remove an index that is managed by ourselves.
     |      This will flush all pending work on that index, and then shut
     |      down its managing thread, and will remove the index.
     |
     |  reset(self)
     |      faiss::Index API
     |      All indices receive the same call
     |
     |  runOnIndex(self, *args)
     |      Run a function on all indices, in the thread that the index is
     |      managed in.
     |      Function arguments are (index in collection, index pointer)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ThreadedIndexBaseBinary(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  own_indices
     |      Whether or not we are responsible for deleting our contained indices
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IndexBinary:
     |
     |  add = replacement_add(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_c = add(self, n, x)
     |       Add n vectors of dimension d to the index.
     |
     |      Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
     |      :type x: uint8_t
     |      :param x:      input matrix, size n * d / 8
     |
     |  add_ex(self, n, x, numeric_type)
     |
     |  add_sa_codes(self, n, codes, xids)
     |      Same as add_with_ids for IndexBinary.
     |
     |  add_with_ids = replacement_add_with_ids(self, x, ids) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  add_with_ids_c = add_with_ids(self, n, x, xids)
     |       Same as add, but stores xids instead of sequential ids.
     |
     |      The default implementation fails with an assertion, as it is
     |      not supported by all indexes.
     |
     |      :type xids: int
     |      :param xids: if non-null, ids to store for the vectors (size n)
     |
     |  add_with_ids_ex(self, n, x, numeric_type, xids)
     |
     |  assign = replacement_assign(self, x, k, labels=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |      Find the k nearest neighbors of the set of vectors x in the index.
     |      This is the same as the `search` method, but discards the distances.
     |
     |      Parameters
     |      ----------
     |      x : array_like
     |          Query vectors, shape (n, d) where d is appropriate for the index.
     |          `dtype` must be uint8.
     |      k : int
     |          Number of nearest neighbors.
     |      labels : array_like, optional
     |          Labels array to store the results.
     |
     |      Returns
     |      -------
     |      labels: array_like
     |          Labels of the nearest neighbors, shape (n, k).
     |          When not enough results are found, the label is set to -1
     |
     |  assign_c = assign(self, n, x, labels, k=1)
     |       Return the indexes of the k vectors closest to the query x.
     |
     |      This function is identical to search but only returns labels of
     |      neighbors.
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |
     |  check_compatible_for_merge(self, otherIndex)
     |       check that the two indexes are compatible (ie, they are
     |      trained in the same way and have the same
     |      parameters). Otherwise throw.
     |
     |  display(self)
     |      Display the actual class name and some more info.
     |
     |  merge_from(self, otherIndex, add_id=0)
     |       moves the entries from another dataset to self.
     |      On output, other is empty.
     |      add_id is added to all moved ids
     |      (for sequential ids, this would be this->ntotal)
     |
     |  range_search = replacement_range_search(self, x, thresh, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  range_search_c = range_search(self, n, x, radius, result, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return all vectors with distance < radius. Note that many indexes
     |      do not implement the range_search (only the k-NN search is
     |      mandatory). The distances are converted to float to reuse the
     |      RangeSearchResult structure, but they are integer. By convention,
     |      only distances < radius (strict comparison) are returned,
     |      ie. radius = 0 does not return any result and 1 returns only
     |      exact same vectors.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type radius: int
     |      :param radius:      search radius
     |      :type result: :py:class:`RangeSearchResult`
     |      :param result:      result table
     |
     |  reconstruct = replacement_reconstruct(self, key) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_c = reconstruct(self, key, recons)
     |       Reconstruct a stored vector.
     |
     |      This function may not be defined for some indexes.
     |      :type key: int
     |      :param key:         id of the vector to reconstruct
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vector (size d / 8)
     |
     |  reconstruct_n = replacement_reconstruct_n(self, n0=0, ni=-1, x=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  reconstruct_n_c = reconstruct_n(self, i0, ni, recons)
     |       Reconstruct vectors i0 to i0 + ni - 1.
     |
     |      This function may not be defined for some indexes.
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors (size ni * d / 8)
     |
     |  remove_ids = replacement_remove_ids(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  remove_ids_c = remove_ids(self, sel)
     |      Removes IDs from the index. Not supported by all indexes.
     |
     |  sa_code_size(self)
     |      size of the produced codes in bytes
     |
     |  search = replacement_search(self, x, k, *, params=None) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  search_and_reconstruct(self, n, x, k, distances, labels, recons, params=None)
     |       Similar to search, but also reconstructs the stored vectors (or an
     |      approximation in the case of lossy coding) for the search results.
     |
     |      If there are not enough results for a query, the resulting array
     |      is padded with -1s.
     |
     |      :type recons: uint8_t
     |      :param recons:      reconstructed vectors size (n, k, d)
     |
     |  search_c = search(self, n, x, k, distances, labels, params=None)
     |       Query n vectors of dimension d to the index.
     |
     |      return at most k vectors. If there are not enough results for a
     |      query, the result array is padded with -1s.
     |
     |      :type x: uint8_t
     |      :param x:           input vectors to search, size n * d / 8
     |      :type labels: int
     |      :param labels:      output labels of the NNs, size n*k
     |      :type distances: int
     |      :param distances:   output pairwise distances, size n*k
     |
     |  search_ex(self, n, x, numeric_type, k, distances, labels, params=None)
     |
     |  train = replacement_train(self, x) from faiss.class_wrappers.handle_IndexBinary.<locals>
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: uint8_t
     |      :param x:      training vectors, size n * d / 8
     |
     |  train_ex(self, n, x, numeric_type)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IndexBinary:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      number of bytes per vector ( = d / 8 )
     |
     |  d
     |      vector dimension
     |
     |  is_trained
     |      set if the Index does not require training, or if training is done
     |      already
     |
     |  metric_type
     |      type of metric this index uses for search
     |
     |  ntotal
     |      total nb of indexed vectors
     |
     |  verbose
     |      verbosity level

    class TimeoutCallback(InterruptCallback)
     |  Method resolution order:
     |      TimeoutCallback
     |      InterruptCallback
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  set_timeout(self, timeout_in_seconds)
     |
     |  want_interrupt(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_TimeoutCallback(...)
     |
     |  reset(timeout_in_seconds)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  start
     |
     |  thisown
     |      The membership flag
     |
     |  timeout
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from InterruptCallback:
     |
     |  check()
     |       check if:
     |      - an interrupt callback is set
     |      - the callback returns true
     |      if this is the case, then throw an exception. Should not be called
     |      from multiple threads.
     |
     |  clear_instance()
     |
     |  get_period_hint(flops)
     |       assuming each iteration takes a certain number of flops, what
     |      is a reasonable interval to check for interrupts?
     |
     |  is_interrupted()
     |      same as check() but return true if is interrupted instead of
     |      throwing. Can be called from multiple threads.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InterruptCallback:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class UInt16Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_UInt16Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class UInt32Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_UInt32Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class UInt64Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_UInt64Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class UInt8Vector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_UInt8Vector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class UInt8VectorVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_UInt8VectorVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class VStackInvertedLists(ReadOnlyInvertedLists)
     |  VStackInvertedLists(n_il, ils)
     |
     |  Method resolution order:
     |      VStackInvertedLists
     |      ReadOnlyInvertedLists
     |      InvertedLists
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, n_il, ils)
     |      build InvertedLists by concatenating nil of them
     |
     |  __repr__ = _swig_repr(self)
     |
     |  get_codes(self, list_no)
     |       get the codes for an inverted list
     |      must be released by release_codes
     |
     |      :rtype: uint8_t
     |      :return: codes    size list_size * code_size
     |
     |  get_ids(self, list_no)
     |       get the ids for an inverted list
     |      must be released by release_ids
     |
     |      :rtype: int
     |      :return: ids      size list_size
     |
     |  get_single_code(self, list_no, offset)
     |      :rtype: uint8_t
     |      :return: a single code in an inverted list
     |          (should be deallocated with release_codes)
     |
     |  get_single_id(self, list_no, offset)
     |      :rtype: int
     |      :return: a single id in an inverted list
     |
     |  list_size(self, list_no)
     |      get the size of a list
     |
     |  prefetch_lists(self, list_nos, nlist_in)
     |      prepare the following lists (default does nothing)
     |      a list can be -1 hence the signed long
     |
     |  release_codes(self, list_no, codes)
     |      release codes returned by get_codes (default implementation is nop
     |
     |  release_ids(self, list_no, ids)
     |      release ids returned by get_ids
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VStackInvertedLists(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  cumsz
     |
     |  ils
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ReadOnlyInvertedLists:
     |
     |  add_entries(self, list_no, n_entry, ids, code)
     |
     |  resize(self, list_no, new_size)
     |
     |  update_entries(self, list_no, offset, n_entry, ids, code)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from InvertedLists:
     |
     |  add_entry(self, list_no, theid, code, inverted_list_context=None)
     |      add one entry to an inverted list
     |
     |  compute_ntotal(self)
     |      sum up list sizes
     |
     |  copy_subset_to(self, other, subset_type, a1, a2)
     |       copy a subset of the entries index to the other index
     |      :rtype: int
     |      :return: number of entries copied
     |
     |  get_iterator(self, list_no, inverted_list_context=None)
     |      get iterable for lists that use_iterator
     |
     |  imbalance_factor(self)
     |      1= perfectly balanced, >1: imbalanced
     |
     |  is_empty(self, list_no, inverted_list_context=None)
     |      check if the list is empty
     |
     |  merge_from(self, oivf, add_id)
     |      move all entries from oivf (empty on output)
     |
     |  print_stats(self)
     |      display some stats about the inverted lists
     |
     |  reset(self)
     |
     |  update_entry(self, list_no, offset, id, code)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from InvertedLists:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  code_size
     |      code size per vector in bytes
     |
     |  nlist
     |      number of possible key values
     |
     |  use_iterator
     |      request to use iterator rather than get_codes / get_ids
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from InvertedLists:
     |
     |  INVALID_CODE_SIZE = 18446744073709551615
     |
     |  SUBSET_TYPE_ELEMENT_RANGE = 2
     |
     |  SUBSET_TYPE_ID_MOD = 1
     |
     |  SUBSET_TYPE_ID_RANGE = 0
     |
     |  SUBSET_TYPE_INVLIST = 4
     |
     |  SUBSET_TYPE_INVLIST_FRACTION = 3

    class VectorIOReader(IOReader)
     |  Method resolution order:
     |      VectorIOReader
     |      IOReader
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VectorIOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  data
     |
     |  rp
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOReader:
     |
     |  filedescriptor(self)
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOReader:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class VectorIOWriter(IOWriter)
     |  Method resolution order:
     |      VectorIOWriter
     |      IOWriter
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VectorIOWriter(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  data
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOWriter:
     |
     |  filedescriptor(self)
     |
     |  write_bytes(self, b) from faiss.class_wrappers.handle_IOWriter.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOWriter:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class VectorTransform(builtins.object)
     |  VectorTransform(*args, **kwargs)
     |
     |  Any transformation applied on a set of vectors
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  apply = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  apply_noalloc(self, n, x, xt)
     |       apply the transformation and return the result in a provided matrix
     |      :type n: int
     |      :param n: number of vectors to transform
     |      :type x: float
     |      :param x: input vectors, size n * d_in
     |      :type xt: float
     |      :param xt: output vectors, size n * d_out
     |
     |  apply_py = apply_method(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  check_identical(self, other)
     |
     |  reverse_transform = replacement_reverse_transform(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  reverse_transform_c = reverse_transform(self, n, xt, x)
     |      reverse transformation. May not be implemented or may return
     |      approximate result
     |
     |  train = replacement_vt_train(self, x) from faiss.class_wrappers.handle_VectorTransform.<locals>
     |
     |  train_c = train(self, n, x)
     |       Perform training on a representative set of vectors. Does
     |      nothing by default.
     |
     |      :type n: int
     |      :param n:      nb of training vectors
     |      :type x: float
     |      :param x:      training vectors, size n * d
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VectorTransform(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  d_in
     |
     |  d_out
     |      input dimension
     |
     |  is_trained
     |      set if the VectorTransform does not require training, or if
     |      training is done already
     |
     |  thisown
     |      The membership flag

    class VectorTransformVector(builtins.object)
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  at(self, n)
     |
     |  clear(self)
     |
     |  data(self)
     |
     |  push_back(self, arg2)
     |
     |  resize(self, n)
     |
     |  size(self)
     |
     |  swap(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VectorTransformVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class VisitedTable(builtins.object)
     |  VisitedTable(*args, **kwargs)
     |
     |  Abstract base class for a fast, reusable Visited Set for graph search
     |  algorithms.
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  advance(self)
     |      reset all flags to false
     |
     |  get(self, no)
     |      get flag #no
     |
     |  prefetch(self, no)
     |      prefetch flag #no
     |
     |  reserve(self, arg2)
     |      pre-allocate bucket space to avoid rehashing during repeated set() calls
     |
     |  set(self, no)
     |      set flag #no to true, return whether this changed it.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VisitedTable(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  thisown
     |      The membership flag

    class VisitedTableSet(VisitedTable)
     |  Set-based implementation using unordered_set.
     |  O(1) to construct and O(visits) to advance.
     |
     |  Method resolution order:
     |      VisitedTableSet
     |      VisitedTable
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  advance(self)
     |      reset all flags to false
     |
     |  get(self, no)
     |      get flag #no
     |
     |  prefetch(self, arg2)
     |      prefetch flag #no
     |
     |  reserve(self, n)
     |      pre-allocate bucket space to avoid rehashing during repeated set() calls
     |
     |  set(self, no)
     |      set flag #no to true, return whether this changed it.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VisitedTableSet(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  visited_set
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VisitedTable:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class VisitedTableVector(VisitedTable)
     |  VisitedTableVector(size)
     |
     |  Vector-based implementation using a versioned byte array.
     |  Faster for get()/set(), but O(size) to initialize.
     |  advance() is O(1) except every 250 calls, which are O(size).
     |
     |  Method resolution order:
     |      VisitedTableVector
     |      VisitedTable
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  advance(self)
     |      reset all flags to false
     |
     |  get(self, no)
     |      get flag #no
     |
     |  prefetch(self, no)
     |      prefetch flag #no
     |
     |  set(self, no)
     |      set flag #no to true, return whether this changed it.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_VisitedTableVector(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  visited
     |
     |  visno
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from VisitedTable:
     |
     |  reserve(self, arg2)
     |      pre-allocate bucket space to avoid rehashing during repeated set() calls
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from VisitedTable:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ZeroCopyIOReader(IOReader)
     |  ZeroCopyIOReader(data, size)
     |
     |  Method resolution order:
     |      ZeroCopyIOReader
     |      IOReader
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__(self, ptr, size, nitems)
     |      Call self as a function.
     |
     |  __init__(self, data, size)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  filedescriptor(self)
     |
     |  get_data_view(self, ptr, size, nitems)
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ZeroCopyIOReader(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  data_
     |
     |  rp_
     |
     |  thisown
     |      The membership flag
     |
     |  total_
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from IOReader:
     |
     |  read_bytes(self, totsz) from faiss.class_wrappers.handle_IOReader.<locals>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IOReader:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  name

    class ZnSphereCodec(ZnSphereSearch, EnumeratedVectors)
     |  ZnSphereCodec(dim_in, r2_in)
     |
     |   codec that can return ids for the encoded vectors
     |
     |  uses the ZnSphereSearch to encode the vector by encoding the
     |  permutation and signs. Depends on ZnSphereSearch because it uses
     |  the atom numbers
     |
     |  Method resolution order:
     |      ZnSphereCodec
     |      ZnSphereSearch
     |      EnumeratedVectors
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, dim_in, r2_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, code, c)
     |      decode it
     |
     |  encode(self, x)
     |      takes vectors that do not need to be centroids
     |
     |  search_and_encode(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ZnSphereCodec(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  code_segments
     |
     |  code_size
     |
     |  nv
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ZnSphereSearch:
     |
     |  search(self, *args)
     |      *Overload 1:*
     |      find nearest centroid. x does not need to be normalized
     |
     |      |
     |
     |      *Overload 2:*
     |      full call. Requires externally-allocated temp space
     |
     |      |
     |
     |      *Overload 3:*
     |      full call. Requires externally-allocated temp space
     |
     |  search_multi(self, n, x, c_out, dp_out)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ZnSphereSearch:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dimS
     |
     |  natom
     |
     |  r2
     |
     |  voc
     |      size dim * natom
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from EnumeratedVectors:
     |
     |  decode_multi(self, nc, codes, c)
     |
     |  encode_multi(self, nc, c, codes)
     |
     |  find_nn(self, n, codes, nq, xq, idx, dis)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EnumeratedVectors:
     |
     |  dim

    class ZnSphereCodecAlt(ZnSphereCodec)
     |  ZnSphereCodecAlt(dim_in, r2_in)
     |
     |   Codec that uses the recursive codec if dim is a power of 2 and
     |  the regular one otherwise
     |
     |  Method resolution order:
     |      ZnSphereCodecAlt
     |      ZnSphereCodec
     |      ZnSphereSearch
     |      EnumeratedVectors
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, dim_in, r2_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, code, c)
     |      decode it
     |
     |  encode(self, x)
     |      takes vectors that do not need to be centroids
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ZnSphereCodecAlt(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  thisown
     |      The membership flag
     |
     |  use_rec
     |
     |  znc_rec
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ZnSphereCodec:
     |
     |  search_and_encode(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ZnSphereCodec:
     |
     |  code_segments
     |
     |  code_size
     |
     |  nv
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ZnSphereSearch:
     |
     |  search(self, *args)
     |      *Overload 1:*
     |      find nearest centroid. x does not need to be normalized
     |
     |      |
     |
     |      *Overload 2:*
     |      full call. Requires externally-allocated temp space
     |
     |      |
     |
     |      *Overload 3:*
     |      full call. Requires externally-allocated temp space
     |
     |  search_multi(self, n, x, c_out, dp_out)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ZnSphereSearch:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dimS
     |
     |  natom
     |
     |  r2
     |
     |  voc
     |      size dim * natom
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from EnumeratedVectors:
     |
     |  decode_multi(self, nc, codes, c)
     |
     |  encode_multi(self, nc, c, codes)
     |
     |  find_nn(self, n, codes, nq, xq, idx, dis)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EnumeratedVectors:
     |
     |  dim

    class ZnSphereCodecRec(EnumeratedVectors)
     |  ZnSphereCodecRec(dim_in, r2_in)
     |
     |   recursive sphere codec
     |
     |  Uses a recursive decomposition on the dimensions to encode
     |  centroids found by the ZnSphereSearch. The codes are *not*
     |  compatible with the ones of ZnSphereCodec
     |
     |  Method resolution order:
     |      ZnSphereCodecRec
     |      EnumeratedVectors
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, dim_in, r2_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  decode(self, code, c)
     |      decode it
     |
     |  encode(self, x)
     |      vectors need to be centroids (does not work on arbitrary
     |      vectors)
     |
     |  encode_centroid(self, c)
     |
     |  get_nv(self, ld, r2a)
     |
     |  get_nv_cum(self, ld, r2t, r2a)
     |
     |  set_nv_cum(self, ld, r2t, r2a, v)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ZnSphereCodecRec(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  all_nv
     |
     |  all_nv_cum
     |
     |  code_size
     |
     |  decode_cache
     |
     |  decode_cache_ld
     |
     |  log2_dim
     |
     |  r2
     |
     |  thisown
     |      The membership flag
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from EnumeratedVectors:
     |
     |  decode_multi(self, nc, codes, c)
     |
     |  encode_multi(self, nc, c, codes)
     |
     |  find_nn(self, n, codes, nq, xq, idx, dis)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EnumeratedVectors:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dim
     |
     |  nv
     |      size of the collection

    class ZnSphereSearch(builtins.object)
     |  ZnSphereSearch(dim, r2_in)
     |
     |   returns the nearest vertex in the sphere to a query. Returns only
     |  the coordinates, not an id.
     |
     |  Algorithm: all points are derived from a one atom vector up to a
     |  permutation and sign changes. The search function finds the most
     |  appropriate atom and transformation.
     |
     |  Methods defined here:
     |
     |  __init__(self, dim, r2_in)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  search(self, *args)
     |      *Overload 1:*
     |      find nearest centroid. x does not need to be normalized
     |
     |      |
     |
     |      *Overload 2:*
     |      full call. Requires externally-allocated temp space
     |
     |      |
     |
     |      *Overload 3:*
     |      full call. Requires externally-allocated temp space
     |
     |  search_multi(self, n, x, c_out, dp_out)
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_ZnSphereSearch(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  dimS
     |
     |  natom
     |
     |  r2
     |
     |  thisown
     |      The membership flag
     |
     |  voc
     |      size dim * natom

    class float_maxheap_array_t(builtins.object)
     |   a template structure for a set of [min|max]-heaps it is tailored
     |  so that the actual data of the heaps can just live in compact
     |  arrays.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
     |       add nj elements to heaps i0:i0+ni, with sequential ids
     |
     |      :type nj: int
     |      :param nj:    nb of elements to add to each heap
     |      :type vin: float
     |      :param vin:   elements to add, size ni * nj
     |      :type j0: int, optional
     |      :param j0:    add this to the ids that are added
     |      :type i0: int, optional
     |      :param i0:    first heap to update
     |      :type ni: int, optional
     |      :param ni:    nb of elements to update (-1 = use nh)
     |
     |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
     |       same as addn_with_ids, but for just a subset of queries
     |
     |      :type nsubset: int
     |      :param nsubset:  number of query entries to update
     |      :type subset: int
     |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
     |
     |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
     |       same as addn
     |
     |      :type id_in: int, optional
     |      :param id_in:     ids of the elements to add, size ni * nj
     |      :type id_stride: int, optional
     |      :param id_stride: stride for id_in
     |
     |  get_ids(self, key)
     |      Corresponding identifiers
     |
     |  get_val(self, key)
     |      Return the list of values for a heap
     |
     |  heapify(self)
     |      prepare all the heaps before adding
     |
     |  per_line_extrema(self, vals_out, idx_out)
     |       this is not really a heap function. It just finds the per-line
     |        extrema of each line of array D
     |      :type vals_out: float
     |      :param vals_out:    extreme value of each line (size nh, or NULL)
     |      :type idx_out: int
     |      :param idx_out:     index of extreme value (size nh or NULL)
     |
     |  reorder(self)
     |      reorder all the heaps
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_float_maxheap_array_t(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ids
     |      identifiers (size nh * k)
     |
     |  k
     |      allocated size per heap
     |
     |  nh
     |      number of heaps
     |
     |  thisown
     |      The membership flag
     |
     |  val
     |      values (distances or similarities), size nh * k

    class float_minheap_array_t(builtins.object)
     |   a template structure for a set of [min|max]-heaps it is tailored
     |  so that the actual data of the heaps can just live in compact
     |  arrays.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
     |       add nj elements to heaps i0:i0+ni, with sequential ids
     |
     |      :type nj: int
     |      :param nj:    nb of elements to add to each heap
     |      :type vin: float
     |      :param vin:   elements to add, size ni * nj
     |      :type j0: int, optional
     |      :param j0:    add this to the ids that are added
     |      :type i0: int, optional
     |      :param i0:    first heap to update
     |      :type ni: int, optional
     |      :param ni:    nb of elements to update (-1 = use nh)
     |
     |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
     |       same as addn_with_ids, but for just a subset of queries
     |
     |      :type nsubset: int
     |      :param nsubset:  number of query entries to update
     |      :type subset: int
     |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
     |
     |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
     |       same as addn
     |
     |      :type id_in: int, optional
     |      :param id_in:     ids of the elements to add, size ni * nj
     |      :type id_stride: int, optional
     |      :param id_stride: stride for id_in
     |
     |  get_ids(self, key)
     |      Corresponding identifiers
     |
     |  get_val(self, key)
     |      Return the list of values for a heap
     |
     |  heapify(self)
     |      prepare all the heaps before adding
     |
     |  per_line_extrema(self, vals_out, idx_out)
     |       this is not really a heap function. It just finds the per-line
     |        extrema of each line of array D
     |      :type vals_out: float
     |      :param vals_out:    extreme value of each line (size nh, or NULL)
     |      :type idx_out: int
     |      :param idx_out:     index of extreme value (size nh or NULL)
     |
     |  reorder(self)
     |      reorder all the heaps
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_float_minheap_array_t(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ids
     |      identifiers (size nh * k)
     |
     |  k
     |      allocated size per heap
     |
     |  nh
     |      number of heaps
     |
     |  thisown
     |      The membership flag
     |
     |  val
     |      values (distances or similarities), size nh * k

    class int_maxheap_array_t(builtins.object)
     |   a template structure for a set of [min|max]-heaps it is tailored
     |  so that the actual data of the heaps can just live in compact
     |  arrays.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
     |       add nj elements to heaps i0:i0+ni, with sequential ids
     |
     |      :type nj: int
     |      :param nj:    nb of elements to add to each heap
     |      :type vin: int
     |      :param vin:   elements to add, size ni * nj
     |      :type j0: int, optional
     |      :param j0:    add this to the ids that are added
     |      :type i0: int, optional
     |      :param i0:    first heap to update
     |      :type ni: int, optional
     |      :param ni:    nb of elements to update (-1 = use nh)
     |
     |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
     |       same as addn_with_ids, but for just a subset of queries
     |
     |      :type nsubset: int
     |      :param nsubset:  number of query entries to update
     |      :type subset: int
     |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
     |
     |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
     |       same as addn
     |
     |      :type id_in: int, optional
     |      :param id_in:     ids of the elements to add, size ni * nj
     |      :type id_stride: int, optional
     |      :param id_stride: stride for id_in
     |
     |  get_ids(self, key)
     |      Corresponding identifiers
     |
     |  get_val(self, key)
     |      Return the list of values for a heap
     |
     |  heapify(self)
     |      prepare all the heaps before adding
     |
     |  per_line_extrema(self, vals_out, idx_out)
     |       this is not really a heap function. It just finds the per-line
     |        extrema of each line of array D
     |      :type vals_out: int
     |      :param vals_out:    extreme value of each line (size nh, or NULL)
     |      :type idx_out: int
     |      :param idx_out:     index of extreme value (size nh or NULL)
     |
     |  reorder(self)
     |      reorder all the heaps
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_int_maxheap_array_t(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ids
     |      identifiers (size nh * k)
     |
     |  k
     |      allocated size per heap
     |
     |  nh
     |      number of heaps
     |
     |  thisown
     |      The membership flag
     |
     |  val
     |      values (distances or similarities), size nh * k

    class int_minheap_array_t(builtins.object)
     |   a template structure for a set of [min|max]-heaps it is tailored
     |  so that the actual data of the heaps can just live in compact
     |  arrays.
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__ = _swig_repr(self)
     |
     |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
     |       add nj elements to heaps i0:i0+ni, with sequential ids
     |
     |      :type nj: int
     |      :param nj:    nb of elements to add to each heap
     |      :type vin: int
     |      :param vin:   elements to add, size ni * nj
     |      :type j0: int, optional
     |      :param j0:    add this to the ids that are added
     |      :type i0: int, optional
     |      :param i0:    first heap to update
     |      :type ni: int, optional
     |      :param ni:    nb of elements to update (-1 = use nh)
     |
     |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
     |       same as addn_with_ids, but for just a subset of queries
     |
     |      :type nsubset: int
     |      :param nsubset:  number of query entries to update
     |      :type subset: int
     |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
     |
     |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
     |       same as addn
     |
     |      :type id_in: int, optional
     |      :param id_in:     ids of the elements to add, size ni * nj
     |      :type id_stride: int, optional
     |      :param id_stride: stride for id_in
     |
     |  get_ids(self, key)
     |      Corresponding identifiers
     |
     |  get_val(self, key)
     |      Return the list of values for a heap
     |
     |  heapify(self)
     |      prepare all the heaps before adding
     |
     |  per_line_extrema(self, vals_out, idx_out)
     |       this is not really a heap function. It just finds the per-line
     |        extrema of each line of array D
     |      :type vals_out: int
     |      :param vals_out:    extreme value of each line (size nh, or NULL)
     |      :type idx_out: int
     |      :param idx_out:     index of extreme value (size nh or NULL)
     |
     |  reorder(self)
     |      reorder all the heaps
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __swig_destroy__ = delete_int_minheap_array_t(...)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ids
     |      identifiers (size nh * k)
     |
     |  k
     |      allocated size per heap
     |
     |  nh
     |      number of heaps
     |
     |  thisown
     |      The membership flag
     |
     |  val
     |      values (distances or similarities), size nh * k

FUNCTIONS
    CMax_float_partition_fuzzy(vals, ids, n, q_min, q_max, q_out)
         partitions the table into 0:q and q:n where all elements above q are >= all
        elements below q (for C = CMax, for CMin comparisons are reversed)

        Returns the partition threshold. The elements q:n are destroyed on output.

    CMax_uint16_partition_fuzzy(*args)

    CMin_float_partition_fuzzy(vals, ids, n, q_min, q_max, q_out)
         partitions the table into 0:q and q:n where all elements above q are >= all
        elements below q (for C = CMax, for CMin comparisons are reversed)

        Returns the partition threshold. The elements q:n are destroyed on output.

    CMin_uint16_partition_fuzzy(*args)

    approx_topk_by_mode(mode, beam_size, n_per_beam, distances, k, bh_val, bh_ids)

    aq_estimate_norm_scale(M, ksub, M_norm, LUT)

    aq_quantize_LUT_and_bias(nprobe, M, ksub, LUT, bias, M_norm, norm_scale, LUTq, M2, biasq, a_out, b_out)

    beam_search_encode_step(*args)
         Encode a residual by sampling from a centroid table.

        This is a single encoding step the residual quantizer.
        It allows low-level access to the encoding function, exposed mainly for unit
        tests.

        :type n: int
        :param n:              number of vectors to handle
        :type residuals: float
        :param residuals:      vectors to encode, size (n, beam_size, d)
        :type cent: float
        :param cent:           centroids, size (K, d)
        :type beam_size: int
        :param beam_size:      input beam size
        :type m: int
        :param m:              size of the codes for the previous encoding steps
        :type codes: int
        :param codes:          code array for the previous steps of the beam (n,
            beam_size, m)
        :type new_beam_size: int
        :param new_beam_size:  output beam size (should be <= K * beam_size)
        :type new_codes: int
        :param new_codes:      output codes, size (n, new_beam_size, m + 1)
        :type new_residuals: float
        :param new_residuals:  output residuals, size (n, new_beam_size, d)
        :type new_distances: float
        :param new_distances:  output distances, size (n, new_beam_size)
        :type assign_index: :py:class:`Index`, optional
        :param assign_index:   if non-NULL, will be used to perform assignment

    beam_search_encode_step_tab(*args)
         Encode a set of vectors using their dot products with the codebooks

        :type K: int
        :param K:           number of vectors in the codebook
        :type n: int
        :param n:           nb of vectors to encode
        :type beam_size: int
        :param beam_size:   input beam size
        :type codebook_cross_norms: float
        :param codebook_cross_norms: inner product of this codebook with the m
                                        previously encoded codebooks
        :type codebook_offsets: int
        :param codebook_offsets:     offsets into codebook_cross_norms for each
                                        previous codebook
        :type query_cp: float
        :param query_cp:    dot products of query vectors with ???
        :type cent_norms_i: float
        :param cent_norms_i:  norms of centroids

    binary_to_real(d, x_in, x_out)
         Convert binary vector to +1/-1 valued float vector.

        :type d: int
        :param d:      dimension of the vector (multiple of 8)
        :type x_in: uint8_t
        :param x_in:   input binary vector (uint8_t table of size d / 8)
        :type x_out: float
        :param x_out:  output float vector (float table of size d)

    bincode_hist(n, nbits, codes, hist)
         Compute histogram of bits on a code array

        :type codes: uint8_t
        :param codes:   size(n, nbits / 8)
        :type hist: int
        :param hist:    size(nbits): nb of 1s in the array of codes

    bitvec_print(b, d)

    bitvec_shuffle(n, da, db, order, a, b)
        Shuffle the bits from b(i, j) := a(i, order[j])

    bitvecs2fvecs(b, x, d, n)

    bucket_sort(nval, vals, nbucket, lims, perm, nt=0)
         Bucket sort of a list of values

        :type vals: int
        :param vals:     values to sort, size nval, max value nbucket - 1
        :type lims: int
        :param lims:     output limits of buckets, size nbucket + 1
        :type perm: int
        :param perm:     output buckets, the elements of bucket
                            i are in perm[lims[i]:lims[i + 1]]
        :type nt: int, optional
        :param nt:       number of threads (0 = pure sequential code)

    bvec_checksum(n, a)
        compute a checksum on a table.

    bvecs_checksum(n, d, a, cs)
         compute checksums for the rows of a matrix

        :type n: int
        :param n:   number of rows
        :type d: int
        :param d:   size per row
        :type a: uint8_t
        :param a:   matrix to handle, size n * d
        :type cs: int
        :param cs:  output checksums, size n

    byte_rand(x, n, seed)

    cast_integer_to_float_ptr(x)

    cast_integer_to_idx_t_ptr(x)

    cast_integer_to_int_ptr(x)

    cast_integer_to_uint8_ptr(x)

    cast_integer_to_void_ptr(x)

    check_compatible_for_merge(index1, index2)
         check if two indexes have the same parameters and are trained in
        the same way, otherwise throw.

    check_openmp()
        Whether OpenMP annotations were respected.

    clone_Quantizer(quant)

    clone_binary_index(index)

    clone_index(arg1)

    compute_1bit_adjusted_distance(normalized_distance, db_factors, query_factors, centered, qb, d)
         Compute adjusted 1-bit distance from normalized LUT distance.
        This is the core distance formula shared by all RaBitQ handlers.

        :type normalized_distance: float
        :param normalized_distance:  Distance from SIMD LUT lookup (after
            normalization)
        :type db_factors: :py:class:`SignBitFactors`
        :param db_factors:          Database vector factors (SignBitFactors or
            SignBitFactorsWithError)
        :type query_factors: :py:class:`QueryFactorsData`
        :param query_factors:       Query factors computed during search
        :type centered: boolean
        :param centered:            Whether centered quantization is used
        :type qb: int
        :param qb:                  Number of quantization bits
        :type d: int
        :param d:                   Dimensionality
        :rtype: float
        :return: Adjusted distance value

    compute_PQ_dis_tables_dsub2(d, ksub, centroids, nx, x, is_inner_product, dis_tables)
        specialized function for PQ2

    compute_codes_add_centroids_mp_lut0(rq, x, codes_out, n, centroids, pool)

    compute_codes_add_centroids_mp_lut1(rq, x, codes_out, n, centroids, pool)

    compute_factors_from_intermediates(norm_L2sqr, or_L2sqr, dp_oO, d, metric_type, compute_error=True)
         Compute final factors from intermediate values.
        :type norm_L2sqr: float
        :param norm_L2sqr:    ||or - c||^2
        :type or_L2sqr: float
        :param or_L2sqr:      ||or||^2
        :type dp_oO: float
        :param dp_oO:         sum of |or_i - c_i|
        :type d: int
        :param d:             dimensionality
        :type metric_type: int
        :param metric_type:   distance metric
        :type compute_error: boolean, optional
        :param compute_error: whether to compute f_error (false for 1-bit mode)
        :rtype: :py:class:`SignBitFactorsWithError`
        :return: computed factors

    compute_full_multibit_distance(sign_bits, ex_code, ex_fac, rotated_q, qr_base, d, ex_bits, metric_type)
         Compute full multi-bit distance from sign bits and ex-bit codes.
        This is the core distance computation shared by RaBitQFastScan handlers.

        The multi-bit distance combines the sign bit (1-bit) with additional
        magnitude bits (ex_bits) to compute a more accurate distance estimate.
        Uses SIMD-optimized bit-plane decomposition (AVX2+BMI2) for ex_bits 1-7,
        with scalar fallback for non-x86 or non-BMI2 platforms.

        :type sign_bits: uint8_t
        :param sign_bits:       unpacked sign bits (1-bit codes in standard format)
        :type ex_code: uint8_t
        :param ex_code:         packed ex-bit codes
        :type ex_fac: :py:class:`ExtraBitsFactors`
        :param ex_fac:          ex-bit factors (f_add_ex, f_rescale_ex)
        :type rotated_q: float
        :param rotated_q:       rotated query vector
        :type qr_base: float
        :param qr_base:         precomputed base term: ||q-c||^2 for L2, <q,c> for IP
        :type d: int
        :param d:               dimensionality
        :type ex_bits: int
        :param ex_bits:         number of extra bits (nb_bits - 1)
        :type metric_type: int
        :param metric_type:     distance metric (L2 or Inner Product)
        :rtype: float
        :return: computed full multi-bit distance

    compute_per_vector_storage_size(nb_bits, d)
         Compute per-vector auxiliary storage size.

        :type nb_bits: int
        :param nb_bits:  number of quantization bits (1 = sign-bit only)
        :type d: int
        :param d:        dimensionality
        :rtype: int
        :return: storage size in bytes

    compute_query_factors(query, d, centroid, qb, centered, metric_type, rotated_q, rotated_qq)
         Compute query factors for RaBitQ distance computation.
        This consolidates the query processing logic shared between implementations.

        :type query: float
        :param query:         query vector (d dimensions)
        :type d: int
        :param d:             dimensionality
        :type centroid: float
        :param centroid:      database centroid (nullptr if not used)
        :type qb: uint8_t
        :param qb:            number of quantization bits (1-8)
        :type centered: boolean
        :param centered:      whether to use centered quantization
        :type metric_type: int
        :param metric_type:   distance metric
        :type rotated_q: std::vector< float >
        :param rotated_q:     output: query - centroid
        :type rotated_qq: std::vector< uint8_t >
        :param rotated_qq:    output: quantized query values
        :rtype: :py:class:`QueryFactorsData`
        :return: computed query factors

    compute_vector_factors(x, d, centroid, metric_type, compute_error=True)
         Compute factors for a single database vector using RaBitQ algorithm.
        This function consolidates the mathematical logic that was duplicated
        between IndexRaBitQ and IndexRaBitQFastScan.

        :type x: float
        :param x:             input vector (d dimensions)
        :type d: int
        :param d:             dimensionality
        :type centroid: float
        :param centroid:      database centroid (nullptr if not used)
        :type metric_type: int
        :param metric_type:   distance metric (L2 or Inner Product)
        :type compute_error: boolean, optional
        :param compute_error: whether to compute f_error (false for 1-bit mode)
        :rtype: :py:class:`SignBitFactorsWithError`
        :return: computed factors for distance computation

    compute_vector_intermediate_values(x, d, centroid, norm_L2sqr, or_L2sqr, dp_oO)
         Compute intermediate values needed for vector factor computation.
        Separated out to allow different bit packing strategies while sharing
        the core mathematical computation.

        :type x: float
        :param x:             input vector (d dimensions)
        :type d: int
        :param d:             dimensionality
        :type centroid: float
        :param centroid:      database centroid (nullptr if not used)
        :type norm_L2sqr: float
        :param norm_L2sqr:    output: ||or - c||^2
        :type or_L2sqr: float
        :param or_L2sqr:      output: ||or||^2
        :type dp_oO: float
        :param dp_oO:         output: sum of |or_i - c_i| (absolute deviations)

    crosshamming_count_thres(dbs, n, ht, ncodes, nptr)

    downcast_AdditiveQuantizer(aq)

    downcast_IndexBinary(index)

    downcast_InvertedLists(il)

    downcast_Quantizer(aq)

    downcast_VectorTransform(vt)

    downcast_index(index)

    extract_bit_fastscan(code, bit_index)
         Extract bit value from FastScan code format.
        Used by IndexRaBitQFastScan which packs bits into 4-bit sub-quantizers.

        :type code: uint8_t
        :param code:          FastScan code data
        :type bit_index: int
        :param bit_index:     which bit to extract (0 to d-1)
        :rtype: boolean
        :return: bit value (true/false)

    extract_bit_standard(code, bit_index)
         Extract bit value from RaBitQ code in standard format.
        Used by IndexRaBitQ which stores bits sequentially.

        :type code: uint8_t
        :param code:          RaBitQ code data
        :type bit_index: int
        :param bit_index:     which bit to extract (0 to d-1)
        :rtype: boolean
        :return: bit value (true/false)

    extract_code_inline(ex_code, index, ex_bits)
         Extract multi-bit code on-the-fly from packed ex-bit codes.
        This inline function extracts a single code value without unpacking the
        entire array, enabling efficient on-the-fly decoding during distance
        computation.

        :type ex_code: uint8_t
        :param ex_code:       packed ex-bit codes
        :type index: int
        :param index:         which code to extract (0 to d-1)
        :type ex_bits: int
        :param ex_bits:       number of bits per code (1-8)
        :rtype: int
        :return: extracted code value in range [0, 2^ex_bits - 1]

    extract_index_ivf(*args)
         get an IndexIVF from an index. The index may be an IndexIVF or
        some wrapper class that encloses an IndexIVF

        throws an exception if this is not the case.

    float_rand(x, n, seed)

    float_randn(x, n, seed)

    fourcc(*args)
        cast a 4-character string to a uint32_t that can be written and read easily

    fourcc_inv(*args)

    fourcc_inv_printable(x)

    fvec2bitvec(x, b, d)

    fvec_L1(x, y, d)
        L1 distance

    fvec_L2sqr(x, y, d)
        Squared L2 distance between two vectors

    fvec_L2sqr_batch_4(x, y0, y1, y2, y3, d, dis0, dis1, dis2, dis3)
        Special version of L2sqr that computes 4 distances
        between x and yi, which is performance oriented.

    fvec_L2sqr_by_idx(dis, x, y, ids, d, nx, ny)
         compute the squared L2 distances between x and a subset y of ny vectors
        defined by ids

        dis(i, j) = inner_product(x(i, :), y(ids(i, j), :))

        :type dis: float
        :param dis:   output array, size nx * ny
        :type x: float
        :param x:     first-term vector, size nx * d
        :type y: float
        :param y:     second-term vector, size (max(ids) + 1) * d
        :type ids: int
        :param ids:   ids to sample from y, size nx * ny

    fvec_L2sqr_ny(dis, x, y, d, ny)

    fvec_L2sqr_ny_nearest(distances_tmp_buffer, x, y, d, ny)

    fvec_L2sqr_ny_nearest_y_transposed(distances_tmp_buffer, x, y, y_sqlen, d, d_offset, ny)

    fvec_L2sqr_ny_transposed(dis, x, y, y_sqlen, d, d_offset, ny)

    fvec_Linf(x, y, d)
        infinity distance

    fvec_add(*args)
        *Overload 1:*
         compute c := a + b for vectors

        c and a can overlap, c and b can overlap

        :type a: float
        :param a: size d
        :type b: float
        :param b: size d
        :type c: float
        :param c: size d

        |

        *Overload 2:*
         compute c := a + b for a, c vectors and b a scalar

        c and a can overlap

        :type a: float
        :param a: size d
        :type c: float
        :param c: size d

    fvec_argsort(n, vals, perm)
         Indirect sort of a floating-point array

        :type n: int
        :param n:     size of the array
        :type vals: float
        :param vals:  array to sort, size n
        :type perm: int
        :param perm:  output: permutation of [0..n-1], st.
                         vals[perm[i + 1]] >= vals[perm[i]]

    fvec_argsort_parallel(n, vals, perm)
        Same as fvec_argsort, parallelized

    fvec_inner_product(x, y, d)
        inner product

    fvec_inner_product_batch_4(x, y0, y1, y2, y3, d, dis0, dis1, dis2, dis3)
        Special version of inner product that computes 4 distances
        between x and yi, which is performance oriented.

    fvec_inner_products_by_idx(ip, x, y, ids, d, nx, ny)
         compute the inner product between x and a subset y of ny vectors defined by
        ids

        ip(i, j) = inner_product(x(i, :), y(ids(i, j), :))

        :type ip: float
        :param ip:    output array, size nx * ny
        :type x: float
        :param x:     first-term vector, size nx * d
        :type y: float
        :param y:     second-term vector, size (max(ids) + 1) * d
        :type ids: int
        :param ids:   ids to sample from y, size nx * ny

    fvec_inner_products_ny(ip, x, y, d, ny)

    fvec_madd(n, a, bf, b, c)
         compute c := a + bf * b for a, b and c tables

        :type n: int
        :param n:   size of the tables
        :type a: float
        :param a:   size n
        :type b: float
        :param b:   size n
        :type c: float
        :param c:   result table, size n

    fvec_madd_and_argmin(n, a, bf, b, c)
         same as fvec_madd, also return index of the min of the result table
        :rtype: int
        :return: index of the min of table c

    fvec_norm_L2sqr(x, d)
        squared norm of a vector

    fvec_norms_L2(norms, x, d, nx)
         compute the L2 norms for a set of vectors

        :type norms: float
        :param norms:    output norms, size nx
        :type x: float
        :param x:        set of vectors, size nx * d

    fvec_norms_L2sqr(norms, x, d, nx)
        same as fvec_norms_L2, but computes squared norms

    fvec_renorm_L2(d, nx, x)

    fvec_sub(d, a, b, c)
         compute c := a - b for vectors

        c and a can overlap, c and b can overlap

        :type a: float
        :param a: size d
        :type b: float
        :param b: size d
        :type c: float
        :param c: size d

    fvecs2bitvecs(x, b, d, n)

    fvecs_maybe_subsample(d, n, nmax, x, verbose=False, seed=1234)
         random subsamples a set of vectors if there are too many of them

        :type d: int
        :param d:      dimension of the vectors
        :type n: int
        :param n:      on input: nb of input vectors, output: nb of output vectors
        :type nmax: int
        :param nmax:   max nb of vectors to keep
        :type x: float
        :param x:      input array, size *n-by-d
        :type seed: int, optional
        :param seed:   random seed to use for sampling
        :rtype: float
        :return: x or an array allocated with new [] with *n vectors

    generalized_hamming_64(a)

    generalized_hammings_knn_hc(ha, a, b, nb, code_size, ordered=1)
        generalized Hamming distances (= count number of code bytes that
           are the same)

    get_compile_options()
        get compile options

    get_cycles()

    get_deserialization_lattice_r2_limit()

    get_deserialization_loop_limit()

    get_deserialization_vector_byte_limit()

    get_extra_distance_computer(d, mt, metric_arg, nb, xb)
        get a DistanceComputer that refers to this type of distance and
        indexes a flat array of size nb

    get_invlist_range(index, i0, i1)
        Get a subset of inverted lists [i0, i1)

    get_mem_usage_kb()
        get current RSS usage in kB

    get_num_gpus()

    get_numeric_type_size(numeric_type)

    get_version()

    getmillisecs()
        ms elapsed since some arbitrary epoch

    gpu_profiler_start()

    gpu_profiler_stop()

    gpu_sync_all_devices()

    greedy_update_nearest(hnsw, qdis, level, nearest, d_nearest)

    hamming_count_thres(bs1, bs2, n1, n2, ht, ncodes, nptr)

    hamming_range_search(a, b, na, nb, radius, ncodes, result, sel=None)
        same as hammings_knn except we are doing a range search with radius

    hammings(a, b, na, nb, nbytespercode, dis)
         Compute a set of Hamming distances between na and nb binary vectors

        :type a: uint8_t
        :param a:             size na * nbytespercode
        :type b: uint8_t
        :param b:             size nb * nbytespercode
        :type nbytespercode: int
        :param nbytespercode: should be multiple of 8
        :type dis: int
        :param dis:           output distances, size na * nb

    hammings_knn(ha, a, b, nb, ncodes, ordered)

    hammings_knn_hc(*args)
         Return the k smallest Hamming distances for a set of binary query vectors,
        using a max heap.
        :type a: uint8_t
        :param a:       queries, size ha->nh * ncodes
        :type b: uint8_t
        :param b:       database, size nb * ncodes
        :type nb: int
        :param nb:      number of database vectors
        :type ncodes: int
        :param ncodes:  size of the binary codes (bytes)
        :type ordered: int
        :param ordered: if != 0: order the results by decreasing distance
                           (may be bottleneck for k/n > 0.01)
        :type approx_topk_mode: int, optional
        :param approx_topk_mode: allows to use approximate top-k facilities
                                    to speedup heap

    hammings_knn_mc(a, b, na, nb, k, ncodes, distances, labels, sel=None)
         Return the k smallest Hamming distances for a set of binary query vectors,
        using counting max.
        :type a: uint8_t
        :param a:       queries, size na * ncodes
        :type b: uint8_t
        :param b:       database, size nb * ncodes
        :type na: int
        :param na:      number of query vectors
        :type nb: int
        :param nb:      number of database vectors
        :type k: int
        :param k:       number of vectors/distances to return
        :type ncodes: int
        :param ncodes:  size of the binary codes (bytes)
        :type distances: int
        :param distances: output distances from each query vector to its k nearest
                           neighbors
        :type labels: int
        :param labels:  output ids of the k nearest neighbors to each query vector

    hash_bytes(bytes, n)
        A reasonable hashing function

    hashtable_int64_to_int64_add(log2_capacity, tab, n, keys, vals)

    hashtable_int64_to_int64_init(log2_capacity, tab)
         Hashtable implementation for int64 -> int64 with external storage
        implemented for fast batch add and lookup.

        tab is of size  2 * (1 << log2_capacity)
        n is the number of elements to add or search

        adding several values in a same batch: an arbitrary one gets added
        in different batches: the newer batch overwrites.
        raises an exception if capacity is exhausted.

    hashtable_int64_to_int64_lookup(log2_capacity, tab, n, keys, vals)

    imbalance_factor(*args)
        *Overload 1:*
        a balanced assignment has a IF of 1, a completely unbalanced assignment has
        an IF = k.

        |

        *Overload 2:*
        same, takes a histogram as input

    index_binary_factory(d, description, own_invlists=True)

    index_factory(*args)
        Build an index with the sequence of processing steps described in
        the string.

    initialize_IVFPQ_precomputed_table(use_precomputed_table, quantizer, pq, precomputed_table, by_residual, verbose)
         Pre-compute distance tables for IVFPQ with by-residual and METRIC_L2

        :type use_precomputed_table: int
        :param use_precomputed_table: (I/O)
                   =-1: force disable
                   =0: decide heuristically (default: use tables only if they are
                       < precomputed_tables_max_bytes), set use_precomputed_table on
            output =1: tables that work for all quantizers (size 256 * nlist * M) =2:
            specific version for MultiIndexQuantizer (much more compact)
        :type precomputed_table: faiss::AlignedTable< float,32 >
        :param precomputed_table: precomputed table to initialize

    inner_product_to_L2sqr(dis, nr1, nr2, n1, n2)

    int64_rand(x, n, seed)

    int64_rand_max(x, n, max, seed)

    is_similarity_metric(metric_type)
        this function is used to distinguish between min and max indexes since
        we need to support similarity and dis-similarity metrics in a flexible way

    ivec_checksum(n, a)
        compute a checksum on a table.

    ivec_hist(n, v, vmax, hist)
        compute histogram on v

    ivf_residual_add_from_flat_codes(ivfrq, ncode, codes, code_size=-1)
         add from codes. NB that the norm component is not used, so the code_size can
        be provided.

        :type ivfrq: :py:class:`IndexIVFResidualQuantizer`
        :param ivfrq:      index to populate with the codes
        :type codes: uint8_t
        :param codes:      codes to add, size (ncode, code_size)
        :type code_size: int, optional
        :param code_size:  override the ivfrq's code_size, useful if the norm encoding
                              is different

    ivf_residual_from_quantizer(arg1, nlevel)
         Build an IndexIVFResidualQuantizer from an ResidualQuantizer, using the
        nlevel first components as coarse quantizer and the rest as codes in invlists

    kmeans1d(x, n, nclusters, centroids)
         Exact 1D K-Means by dynamic programming

        From  "Fast Exact k-Means, k-Medians and Bregman Divergence Clustering in 1D"
        Allan Grønlund, Kasper Green Larsen, Alexander Mathiasen, Jesper Sindahl
        Nielsen, Stefan Schneider, Mingzhou Song, ArXiV'17

        Section 2.2

        https://arxiv.org/abs/1701.07204

        :type x: float
        :param x:          input 1D array
        :type n: int
        :param n:          input array length
        :type nclusters: int
        :param nclusters:  number of clusters
        :type centroids: float
        :param centroids:  output centroids, size nclusters
        :rtype: float
        :return: imbalance factor

    kmeans_clustering(d, n, k, x, centroids)
         simplified interface

        :type d: int
        :param d: dimension of the data
        :type n: int
        :param n: nb of training vectors
        :type k: int
        :param k: nb of output centroids
        :type x: float
        :param x: training set (size n * d)
        :type centroids: float
        :param centroids: output centroids (size k * d)
        :rtype: float
        :return: final quantization error

    knn_L2sqr(*args)
        *Overload 1:*
         Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, for the L2 distance
        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type res: :py:class:`float_maxheap_array_t`
        :param res:  result heap structure, which also provides k. Sorted on output
        :type y_norm2: float, optional
        :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
        :type sel: :py:class:`IDSelector`, optional
        :param sel:  search in this subset of vectors

        |

        *Overload 2:*
          Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, for the L2 distance

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type distances: float
        :param distances:  output distances, size nq * k
        :type indexes: int
        :param indexes:    output vector ids, size nq * k
        :type y_norm2: float, optional
        :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
        :type sel: :py:class:`IDSelector`, optional
        :param sel:  search in this subset of vectors

        |

        *Overload 3:*
          Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, for the L2 distance

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type distances: float
        :param distances:  output distances, size nq * k
        :type indexes: int
        :param indexes:    output vector ids, size nq * k
        :type y_norm2: float, optional
        :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
        :param sel:  search in this subset of vectors

        |

        *Overload 4:*
          Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, for the L2 distance

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type distances: float
        :param distances:  output distances, size nq * k
        :type indexes: int
        :param indexes:    output vector ids, size nq * k
        :param y_norm2:    (optional) norms for the y vectors (nullptr or size ny)
        :param sel:  search in this subset of vectors

    knn_L2sqr_by_idx(x, y, subset, d, nx, ny, nsubset, k, vals, ids, ld_subset=-1)
         Find the nearest neighbors for nx queries in a set of ny vectors
        indexed by ids. May be useful for re-ranking a pre-selected vector list

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size (max(ids) + 1) * d
        :type subset: int
        :param subset: subset of database vectors to consider, size (nx, nsubset)
        :param res:  result structure
        :type ld_subset: int, optional
        :param ld_subset: stride for the subset array. -1: use nsubset, 0: all queries
            process the same subset

    knn_extra_metrics(x, y, d, nx, ny, mt, metric_arg, k, distances, indexes, sel=None)

    knn_inner_product(*args)
        *Overload 1:*
         Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, w.r.t to max inner product.

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type res: :py:class:`float_minheap_array_t`
        :param res:  result heap structure, which also provides k. Sorted on output

        |

        *Overload 2:*
          Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, for the inner product metric.

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type distances: float
        :param distances:  output distances, size nq * k
        :type indexes: int
        :param indexes:    output vector ids, size nq * k

        |

        *Overload 3:*
          Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, for the inner product metric.

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size ny * d
        :type distances: float
        :param distances:  output distances, size nq * k
        :type indexes: int
        :param indexes:    output vector ids, size nq * k

    knn_inner_products_by_idx(x, y, subset, d, nx, ny, nsubset, k, vals, ids, ld_ids=-1)
         Find the max inner product neighbors for nx queries in a set of ny vectors
        indexed by ids. May be useful for re-ranking a pre-selected vector list

        :type x: float
        :param x:    query vectors, size nx * d
        :type y: float
        :param y:    database vectors, size (max(ids) + 1) * d
        :type ids: int
        :param ids:  subset of database vectors to consider, size (nx, nsubset)
        :param res:  result structure
        :type ld_ids: int, optional
        :param ld_ids: stride for the ids array. -1: use nsubset, 0: all queries
            process the same subset

    lo_build(list_id, offset)

    lo_listno(lo)

    lo_offset(lo)

    match_hamming_thres(bs1, bs2, n1, n2, ht, ncodes, idx, dis)

    matrix_bucket_sort_inplace(*args)
        *Overload 1:*
         in-place bucket sort (with attention to memory=>int32)
        on input the values are in a nrow * col matrix
        we want to store the row numbers in the output.

        :type vals: int
        :param vals:     positive values to sort, size nrow * ncol,
                            max value nbucket - 1
        :type lims: int
        :param lims:     output limits of buckets, size nbucket + 1
        :type nt: int, optional
        :param nt:       number of threads (0 = pure sequential code)

        |

        *Overload 2:*
         same with int64 elements

        |

        *Overload 3:*
         same with int64 elements

    matrix_qr(m, n, a)
         compute the Q of the QR decomposition for m > n
        :type a: float
        :param a:   size n * m: input matrix and output Q

    memcpy(dest, src, n)

    merge_into(index0, index1, shift_ids)
         Merge index1 into index0. Works on IndexIVF's and IndexIVF's
         embedded in a IndexPreTransform. On output, the index1 is empty.

        :type shift_ids: boolean
        :param shift_ids:: translate the ids from index1 to index0->prev_ntotal

    merge_knn_results_CMax(*args)

    merge_knn_results_CMin(*args)

    merge_result_table_with(n, k, I0, D0, I1, D1, keep_min=True, translation=0)
         merge a result table into another one

        :type I0: int
        :param I0:, D0       first result table, size (n, k)
        :type I1: int
        :param I1:, D1       second result table, size (n, k)
        :type keep_min: boolean, optional
        :param keep_min:     if true, keep min values, otherwise keep max
        :type translation: int, optional
        :param translation:  add this value to all I1's indexes
        :rtype: int
        :return: nb of values that were taken from the second table

    metric_type_count()
        Count of entries in the MetricType enum.

    metric_type_from_int(x)
        Convert an integer to MetricType with range validation.
        Throws FaissException if the value is not a valid MetricType.

    omp_get_max_threads()

    omp_set_num_threads(num_threads)

    pack_bitstrings(*args)
        *Overload 1:*
         Pack a set of n codes of size M * nbit

        :type n: int
        :param n:           number of codes to pack
        :type M: int
        :param M:           number of elementary codes per code
        :type nbit: int
        :param nbit:        number of bits per elementary code
        :type unpacked: int
        :param unpacked:    input unpacked codes, size (n, M)
        :type packed: uint8_t
        :param packed:      output packed codes, size (n, code_size)
        :type code_size: int
        :param code_size:   should be >= ceil(M * nbit / 8)

        |

        *Overload 2:*
         Pack a set of n codes of variable sizes

        :param nbit:       number of bits per entry (size M)

    pairwise_L2sqr(d, nq, xq, nb, xb, dis, ldq=-1, ldb=-1, ldd=-1)
         Compute pairwise distances between sets of vectors

        :type d: int
        :param d:     dimension of the vectors
        :type nq: int
        :param nq:    nb of query vectors
        :type nb: int
        :param nb:    nb of database vectors
        :type xq: float
        :param xq:    query vectors (size nq * d)
        :type xb: float
        :param xb:    database vectors (size nb * d)
        :type dis: float
        :param dis:   output distances (size nq * nb)
        :param ldq,ldb:, ldd strides for the matrices

    pairwise_extra_distances(d, nq, xq, nb, xb, mt, metric_arg, dis, ldq=-1, ldb=-1, ldd=-1)

    pairwise_indexed_L2sqr(d, n, x, ix, y, iy, dis)
         compute dis[j] = L2sqr(x[ix[j]], y[iy[j]]) forall j=0..n-1

        :type x: float
        :param x:  size (max(ix) + 1, d)
        :type y: float
        :param y:  size (max(iy) + 1, d)
        :type ix: int
        :param ix: size n
        :type iy: int
        :param iy: size n
        :type dis: float
        :param dis: size n

    pairwise_indexed_inner_product(d, n, x, ix, y, iy, dis)
         compute dis[j] = inner_product(x[ix[j]], y[iy[j]]) forall j=0..n-1

        :type x: float
        :param x:  size (max(ix) + 1, d)
        :type y: float
        :param y:  size (max(iy) + 1, d)
        :type ix: int
        :param ix: size n
        :type iy: int
        :param iy: size n
        :type dis: float
        :param dis: size n

    popcount32(x)

    popcount64(x)

    populate_block_aux_from_flat_storage(flat_storage, codes, num_vectors, bbs, M2, old_block_stride, new_block_stride, storage_size, id_map=None)
         [LEGACY FORMAT SUPPORT] Migrate block data from old I/O format to new
        format.

        This function is used only when reading indexes saved with the legacy format
        (fourcc "Irfs"/"Iwrf") to convert them to the new embedded auxiliary data
        format. Not needed for indexes saved with the new format ("Irfn"/"Iwrn").

        Re-layouts blocks in-place and copies aux data from flat_storage.

        :type flat_storage: std::vector< uint8_t >
        :param flat_storage:       legacy per-vector aux data indexed by global ID
        :type codes: faiss::AlignedTable< uint8_t >
        :param codes:              block data (will be resized and re-laid out)
        :type num_vectors: int
        :param num_vectors:        number of vectors in this segment
        :type bbs: int
        :param bbs:                block batch size (vectors per block)
        :type M2: int
        :param M2:                 rounded sub-quantizer count
        :type old_block_stride: int
        :param old_block_stride:   old block size (packed codes only, or current)
        :type new_block_stride: int
        :param new_block_stride:   new block size (packed codes + aux region)
        :type storage_size: int
        :param storage_size:       per-vector aux storage size in bytes
        :type id_map: int, optional
        :param id_map:             maps local offset to global ID; null = sequential

    quantize_LUT_and_bias(nprobe, M, ksub, lut_is_3d, LUT, bias, LUTq, M2, biasq, a_out=None, b_out=None)
         LUT quantization to uint8 and bias to uint16.

        (nprobe, M, ksub, lut_is_3d) determine the size of the LUT

         LUT input:
         - 2D size (M, ksub): single matrix per probe (lut_is_3d=false)
         - 3D size (nprobe, M, ksub): separate LUT per probe (lut_is_3d=true)
         bias input:
         - nullptr: bias is 0
         - size (nprobe): one bias per probe
         Output:
         - LUTq uint8 version of the LUT (M size is rounded up to M2)
         - biasq (or nullptr): uint16 version of the LUT
         - a, b: scalars to approximate the true distance

    rand_perm(perm, n, seed)

    rand_perm_splitmix64(perm, n, seed)

    rand_smooth_vectors(n, d, x, seed)

    range_search_L2sqr(x, y, d, nx, ny, radius, result, sel=None)
         Return the k nearest neighbors of each of the nx vectors x among the ny
         vector y, w.r.t to max inner product

        :type x: float
        :param x:      query vectors, size nx * d
        :type y: float
        :param y:      database vectors, size ny * d
        :type radius: float
        :param radius: search radius around the x vectors
        :type result: :py:class:`RangeSearchResult`
        :param result: result structure

    range_search_inner_product(x, y, d, nx, ny, radius, result, sel=None)
        same as range_search_L2sqr for the inner product similarity

    range_search_with_parameters(index, n, x, radius, result, params, nb_dis=None, ms_per_stage=None)
        same as search_with_parameters but for range search

    ranklist_handle_ties(k, idx, dis)
        distances are supposed to be sorted. Sorts indices with same distance

    ranklist_intersection_size(k1, v1, k2, v2)
         count the number of common elements between v1 and v2
        algorithm = sorting + bisection to avoid double-counting duplicates

    read_InvertedLists(reader, io_flags=0)

    read_ProductQuantizer(*args)

    read_VectorTransform(*args)

    read_index(*args)

    read_index_binary(*args)

    real_to_binary(d, x_in, x_out)
         Convert float vector to binary vector. Components > 0 are converted to 1,
        others to 0.

        :type d: int
        :param d:      dimension of the vector (multiple of 8)
        :type x_in: float
        :param x_in:   input float vector (float table of size d)
        :type x_out: uint8_t
        :param x_out:  output binary vector (uint8_t table of size d / 8)

    refine_beam_LUT_mp(rq, n, query_norms, query_cp, out_beam_size, out_codes, out_distances, pool)

    refine_beam_mp(rq, n, beam_size, x, out_beam_size, out_codes, out_residuals, out_distances, pool)

    reflection(u, x, n, d, nu)

    rev_swig_ptr(*args)

    round_uint8_per_column(tab, n, d, a_out=None, b_out=None)
         Functions to quantize PQ floating-point Look Up Tables (LUT) to uint8, and
        biases to uint16. The accumulation is supposed to take place in uint16.
        The quantization coefficients are float (a, b) such that

             original_value = quantized_value * a / b

        The hardest part of the quantization is with multiple LUTs that need to be
        added up together. In that case, coefficient a has to be chosen so that
        the sum fits in a uint16 accumulator.

    round_uint8_per_column_multi(tab, m, n, d, a_out=None, b_out=None)

    search_and_return_centroids(index, n, xin, k, distances, labels, query_centroid_ids, result_centroid_ids)

    search_centroid(index, x, n, centroid_ids)

    search_from_candidate_unbounded(hnsw, node, qdis, ef, vt, stats)

    search_from_candidates(hnsw, qdis, res, candidates, vt, stats, level, nres_in=0, params=None)
        Internal HNSW algorithm helpers. These are not part of the public API; they
        are exposed here only so that unit tests (and a few cross-TU callers such as
        the Panorama search variant) can reach them.

    search_from_candidates_panorama(hnsw, index, qdis, res, candidates, vt, stats, level, nres_in=0, params=None)
        Equivalent to `search_from_candidates`, but applies pruning with progressive
        refinement bounds.
        This is used in `IndexHNSWFlatPanorama` to improve the search performance
        for higher dimensional vectors.

    search_neighbors_to_add(hnsw, qdis, results, entry_point, d_entry_point, level, vt, reference_version=False)

    search_with_parameters(index, n, x, k, distances, labels, params, nb_dis=None, ms_per_stage=None)
         search an IndexIVF, possibly embedded in an IndexPreTransform with
        given parameters. This is a way to set the nprobe and get
        statdistics in a thread-safe way.

        Optionally returns (if non-nullptr):
        - nb_dis: number of distances computed
        - ms_per_stage: [0]: preprocessing time
                        [1]: coarse quantization,
                        [2]: list scanning

    set_bit_fastscan(code, bit_index)
         Set bit value in FastScan code format.
        :type code: uint8_t
        :param code:          FastScan code data to modify
        :type bit_index: int
        :param bit_index:     which bit to set (0 to d-1)

    set_bit_standard(code, bit_index)
         Set bit value in standard RaBitQ code format.
        :type code: uint8_t
        :param code:          RaBitQ code data to modify
        :type bit_index: int
        :param bit_index:     which bit to set (0 to d-1)

    set_deserialization_lattice_r2_limit(value)

    set_deserialization_loop_limit(value)

    set_deserialization_vector_byte_limit(value)

    set_invlist_range(index, i0, i1, src)
        Set a subset of inverted lists

    shard_binary_ivf_index_centroids(*args)

    shard_ivf_index_centroids(*args)
        Shards an IVF index centroids by the given sharding function, and writes
        the index to the path given by filename_generator. The centroids must already
        be added to the index quantizer.

        :type index: :py:class:`IndexIVF`
        :param index:             The IVF index containing centroids to shard.
        :type shard_count: int, optional
        :param shard_count:       Number of shards.
        :type filename_template: string, optional
        :param filename_template: Template for shard filenames.
        :type sharding_function: :py:class:`ShardingFunction`, optional
        :param sharding_function: The function to shard by. The default is ith vector
                                     mod shard_count.
        :type generate_ids: boolean, optional
        :param generate_ids:      Generates ids using IndexIDMap2. If true, ids will
                                     match the default ids in the unsharded index.
        :rtype: void
        :return: The number of shards written.

    should_refine_candidate(est_distance, f_error, g_error, threshold, is_similarity)
         Determine whether a candidate should be refined in two-stage search.
        Consolidates the filtering logic for both L2 and IP metrics.

        For L2 (min-heap): uses lower_bound = est_distance - error_adjustment
          - Skip if lower_bound >= threshold (can't beat current worst)
        For IP (max-heap): uses upper_bound = est_distance + error_adjustment
          - Skip if upper_bound <= threshold (can't beat current best)

        :type est_distance: float
        :param est_distance:     Estimated 1-bit distance
        :type f_error: float
        :param f_error:          Database vector error factor
        :type g_error: float
        :param g_error:          Query vector error factor
        :type threshold: float
        :param threshold:        Current heap threshold (worst result in heap)
        :type is_similarity: boolean
        :param is_similarity:    True for IP metric (max-heap), false for L2
            (min-heap)
        :rtype: boolean
        :return: True if candidate should be refined with full
            multi-bit distance

    simd_histogram_16(data, n, min, shift, hist)
        same for 16-bin histogram

    simd_histogram_8(data, n, min, shift, hist)
         low level SIMD histogramming functions  8-bin histogram of (x - min) >> shift
        values outside the range are ignored.
        the data table should be aligned on 32 bytes

    smawk(nrows, ncols, x, argmins)
         SMAWK algorithm. Find the row minima of a monotone matrix.

        Expose this for testing.

        :type nrows: int
        :param nrows:    number of rows
        :type ncols: int
        :param ncols:    number of columns
        :type x: float
        :param x:        input matrix, size (nrows, ncols)
        :type argmins: int
        :param argmins:  argmin of each row

    storage_distance_computer(storage)

    swig_ptr(a)

    swig_version()

    to_simd_level(level_str)
        Parse string to SIMDLevel. Throws FaissException for invalid strings.

    to_string(level)
        Convert SIMDLevel to string. Throws FaissException for invalid level.

    try_extract_index_ivf(*args)
        same as above but returns nullptr instead of throwing on failure

    unpack_bitstrings(*args)
        *Overload 1:*
         Unpack a set of n codes of size M * nbit

        :type n: int
        :param n:           number of codes to pack
        :type M: int
        :param M:           number of elementary codes per code
        :type nbit: int
        :param nbit:        number of bits per elementary code
        :type unpacked: int
        :param unpacked:    input unpacked codes, size (n, M)
        :type packed: uint8_t
        :param packed:      output packed codes, size (n, code_size)
        :type code_size: int
        :param code_size:   should be >= ceil(M * nbit / 8)

        |

        *Overload 2:*
         Unpack a set of n codes of variable sizes

        :param nbit:       number of bits per entry (size M)

    unpack_sign_bits_from_packed(block, bbs, nsq, offset, block_stride, sign_bits_out)
        Extract sign bits from PQ4-interleaved block into flat byte packing.
        Like CodePackerRaBitQ::unpack_1 but sign-bits-only and with the
        vector's in-block address hoisted out of the per-SQ loop.

    write_InvertedLists(ils, f)

    write_ProductQuantizer(*args)

    write_VectorTransform(*args)

    write_index(*args)

    write_index_binary(*args)

DATA
    APPROX_TOPK_BUCKETS_B16_D2 = 3
    APPROX_TOPK_BUCKETS_B32_D2 = 1
    APPROX_TOPK_BUCKETS_B8_D2 = 4
    APPROX_TOPK_BUCKETS_B8_D3 = 2
    ClusteringInitMethod_AFK_MC2 = 2
    ClusteringInitMethod_KMEANS_PLUS_PLUS = 1
    ClusteringInitMethod_RANDOM = 0
    EXACT_TOPK = 0
    FAISS_VERSION_MAJOR = 1
    FAISS_VERSION_MINOR = 14
    FAISS_VERSION_PATCH = 3
    Float16 = 1
    Float32 = 0
    IO_FLAG_MMAP = 1684996104
    IO_FLAG_MMAP_IFC = 512
    IO_FLAG_ONDISK_SAME_DIR = 4
    IO_FLAG_PQ_SKIP_SDC_TABLE = 32
    IO_FLAG_READ_ONLY = 2
    IO_FLAG_SKIP_IVF_DATA = 8
    IO_FLAG_SKIP_PRECOMPUTE_TABLE = 16
    IO_FLAG_SKIP_STORAGE = 1
    Int8 = 3
    METRIC_BrayCurtis = 21
    METRIC_Canberra = 20
    METRIC_GOWER = 25
    METRIC_INNER_PRODUCT = 0
    METRIC_Jaccard = 23
    METRIC_JensenShannon = 22
    METRIC_L1 = 2
    METRIC_L2 = 1
    METRIC_Linf = 3
    METRIC_Lp = 4
    METRIC_NaNEuclidean = 24
    SHARED_PTR_DISOWN = 0
    SIMDLevel_ARM_NEON = 4
    SIMDLevel_ARM_SVE = 5
    SIMDLevel_AVX2 = 1
    SIMDLevel_AVX512 = 2
    SIMDLevel_AVX512_SPR = 3
    SIMDLevel_COUNT = 7
    SIMDLevel_NONE = 0
    SIMDLevel_RISCV_RVV = 6
    SINGLE_SIMD_LEVEL = 0
    SINGLE_SIMD_LEVEL_256 = 0
    SINGLE_SIMD_LEVEL_512 = 0
    UInt8 = 2
    VERSION_STRING = '1.14.3'
    Z_MAX_BY_QB = <Swig Object of type 'float *'>
    cvar = <Swig global variables>
    hamdis_tab_ham_bytes = <Swig Object of type 'unsigned char *'>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\swigfaiss.py

Error rendering doc: No Python documentation found for 'write_index_binary'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

Python Library Documentation: built-in module sys

NAME
    sys

MODULE REFERENCE
    https://docs.python.org/3.12/library/sys.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module provides access to some objects used or maintained by the
    interpreter and to functions that interact strongly with the interpreter.

    Dynamic objects:

    argv -- command line arguments; argv[0] is the script pathname if known
    path -- module search path; path[0] is the script directory, else ''
    modules -- dictionary of loaded modules

    displayhook -- called to show results in an interactive session
    excepthook -- called to handle any uncaught exception other than SystemExit
      To customize printing in an interactive session or to install a custom
      top-level exception handler, assign other functions to replace these.

    stdin -- standard input file object; used by input()
    stdout -- standard output file object; used by print()
    stderr -- standard error object; used for error messages
      By assigning other file objects (or objects that behave like files)
      to these, it is possible to redirect all of the interpreter's I/O.

    last_exc - the last uncaught exception
      Only available in an interactive session after a
      traceback has been printed.
    last_type -- type of last uncaught exception
    last_value -- value of last uncaught exception
    last_traceback -- traceback of last uncaught exception
      These three are the (deprecated) legacy representation of last_exc.

    Static objects:

    builtin_module_names -- tuple of module names built into this interpreter
    copyright -- copyright notice pertaining to this interpreter
    exec_prefix -- prefix used to find the machine-specific Python library
    executable -- absolute path of the executable binary of the Python interpreter
    float_info -- a named tuple with information about the float implementation.
    float_repr_style -- string indicating the style of repr() output for floats
    hash_info -- a named tuple with information about the hash algorithm.
    hexversion -- version information encoded as a single integer
    implementation -- Python implementation information.
    int_info -- a named tuple with information about the int implementation.
    maxsize -- the largest supported length of containers.
    maxunicode -- the value of the largest Unicode code point
    platform -- platform identifier
    prefix -- prefix used to find the Python library
    thread_info -- a named tuple with information about the thread implementation.
    version -- the version of this interpreter as a string
    version_info -- version information as a named tuple
    dllhandle -- [Windows only] integer handle of the Python DLL
    winver -- [Windows only] version number of the Python DLL
    _enablelegacywindowsfsencoding -- [Windows only]
    __stdin__ -- the original stdin; don't touch!
    __stdout__ -- the original stdout; don't touch!
    __stderr__ -- the original stderr; don't touch!
    __displayhook__ -- the original displayhook; don't touch!
    __excepthook__ -- the original excepthook; don't touch!

    Functions:

    displayhook() -- print an object to the screen, and save it in builtins._
    excepthook() -- print an exception and its traceback to sys.stderr
    exception() -- return the current thread's active exception
    exc_info() -- return information about the current thread's active exception
    exit() -- exit the interpreter by raising SystemExit
    getdlopenflags() -- returns flags to be used for dlopen() calls
    getprofile() -- get the global profiling function
    getrefcount() -- return the reference count for an object (plus one :-)
    getrecursionlimit() -- return the max recursion depth for the interpreter
    getsizeof() -- return the size of an object in bytes
    gettrace() -- get the global debug tracing function
    setdlopenflags() -- set the flags to be used for dlopen() calls
    setprofile() -- set the global profiling function
    setrecursionlimit() -- set the max recursion depth for the interpreter
    settrace() -- set the global debug tracing function

SUBMODULES
    monitoring

FUNCTIONS
    __breakpointhook__ = breakpointhook(...)
        breakpointhook(*args, **kws)

        This hook function is called by built-in breakpoint().

    __displayhook__ = displayhook(object, /)
        Print an object to sys.stdout and also save it in builtins._

    __excepthook__ = excepthook(exctype, value, traceback, /)
        Handle an exception by displaying it with a traceback on sys.stderr.

    __unraisablehook__ = unraisablehook(unraisable, /)
        Handle an unraisable exception.

        The unraisable argument has the following attributes:

        * exc_type: Exception type.
        * exc_value: Exception value, can be None.
        * exc_traceback: Exception traceback, can be None.
        * err_msg: Error message, can be None.
        * object: Object causing the exception, can be None.

    activate_stack_trampoline(backend, /)
        Activate stack profiler trampoline *backend*.

    addaudithook(hook)
        Adds a new audit hook callback.

    audit(...)
        audit(event, *args)

        Passes the event to any audit hooks that are attached.

    breakpointhook(...)
        breakpointhook(*args, **kws)

        This hook function is called by built-in breakpoint().

    call_tracing(func, args, /)
        Call func(*args), while tracing is enabled.

        The tracing state is saved, and restored afterwards.  This is intended
        to be called from a debugger from a checkpoint, to recursively debug
        some other code.

    deactivate_stack_trampoline()
        Deactivate the current stack profiler trampoline backend.

        If no stack profiler is activated, this function has no effect.

    displayhook(object, /)
        Print an object to sys.stdout and also save it in builtins._

    exc_info()
        Return current exception information: (type, value, traceback).

        Return information about the most recent exception caught by an except
        clause in the current stack frame or in an older stack frame.

    excepthook(exctype, value, traceback, /)
        Handle an exception by displaying it with a traceback on sys.stderr.

    exception()
        Return the current exception.

        Return the most recent exception caught by an except clause
        in the current stack frame or in an older stack frame, or None
        if no such exception exists.

    exit(status=None, /)
        Exit the interpreter by raising SystemExit(status).

        If the status is omitted or None, it defaults to zero (i.e., success).
        If the status is an integer, it will be used as the system exit status.
        If it is another kind of object, it will be printed and the system
        exit status will be one (i.e., failure).

    get_asyncgen_hooks()
        Return the installed asynchronous generators hooks.

        This returns a namedtuple of the form (firstiter, finalizer).

    get_coroutine_origin_tracking_depth()
        Check status of origin tracking for coroutine objects in this thread.

    get_int_max_str_digits()
        Return the maximum string digits limit for non-binary int<->str conversions.

    getallocatedblocks()
        Return the number of memory blocks currently allocated.

    getdefaultencoding()
        Return the current default encoding used by the Unicode implementation.

    getfilesystemencodeerrors()
        Return the error mode used Unicode to OS filename conversion.

    getfilesystemencoding()
        Return the encoding used to convert Unicode filenames to OS filenames.

    getprofile()
        Return the profiling function set with sys.setprofile.

        See the profiler chapter in the library manual.

    getrecursionlimit()
        Return the current value of the recursion limit.

        The recursion limit is the maximum depth of the Python interpreter
        stack.  This limit prevents infinite recursion from causing an overflow
        of the C stack and crashing Python.

    getrefcount(object, /)
        Return the reference count of object.

        The count returned is generally one higher than you might expect,
        because it includes the (temporary) reference as an argument to
        getrefcount().

    getsizeof(...)
        getsizeof(object [, default]) -> int

        Return the size of object in bytes.

    getswitchinterval()
        Return the current thread switch interval; see sys.setswitchinterval().

    gettrace()
        Return the global debug tracing function set with sys.settrace.

        See the debugger chapter in the library manual.

    getunicodeinternedsize()
        Return the number of elements of the unicode interned dictionary

    getwindowsversion()
        Return info about the running version of Windows as a named tuple.

        The members are named: major, minor, build, platform, service_pack,
        service_pack_major, service_pack_minor, suite_mask, product_type and
        platform_version. For backward compatibility, only the first 5 items
        are available by indexing. All elements are numbers, except
        service_pack and platform_type which are strings, and platform_version
        which is a 3-tuple. Platform is always 2. Product_type may be 1 for a
        workstation, 2 for a domain controller, 3 for a server.
        Platform_version is a 3-tuple containing a version number that is
        intended for identifying the OS rather than feature detection.

    intern(string, /)
        ``Intern'' the given string.

        This enters the string in the (global) table of interned strings whose
        purpose is to speed up dictionary lookups. Return the string itself or
        the previously interned string object with the same value.

    is_finalizing()
        Return True if Python is exiting.

    is_stack_trampoline_active()
        Return *True* if a stack profiler trampoline is active.

    set_asyncgen_hooks(...)
        set_asyncgen_hooks([firstiter] [, finalizer])

        Set a finalizer for async generators objects.

    set_coroutine_origin_tracking_depth(depth)
        Enable or disable origin tracking for coroutine objects in this thread.

        Coroutine objects will track 'depth' frames of traceback information
        about where they came from, available in their cr_origin attribute.

        Set a depth of 0 to disable.

    set_int_max_str_digits(maxdigits)
        Set the maximum string digits limit for non-binary int<->str conversions.

    setprofile(...)
        setprofile(function)

        Set the profiling function.  It will be called on each function call
        and return.  See the profiler chapter in the library manual.

    setrecursionlimit(limit, /)
        Set the maximum depth of the Python interpreter stack to n.

        This limit prevents infinite recursion from causing an overflow of the C
        stack and crashing Python.  The highest possible limit is platform-
        dependent.

    setswitchinterval(interval, /)
        Set the ideal thread switching delay inside the Python interpreter.

        The actual frequency of switching threads can be lower if the
        interpreter executes long sequences of uninterruptible code
        (this is implementation-specific and workload-dependent).

        The parameter must represent the desired switching delay in seconds
        A typical value is 0.005 (5 milliseconds).

    settrace(...)
        settrace(function)

        Set the global debug tracing function.  It will be called on each
        function call.  See the debugger chapter in the library manual.

    unraisablehook(unraisable, /)
        Handle an unraisable exception.

        The unraisable argument has the following attributes:

        * exc_type: Exception type.
        * exc_value: Exception value, can be None.
        * exc_traceback: Exception traceback, can be None.
        * err_msg: Error message, can be None.
        * object: Object causing the exception, can be None.

DATA
    __stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1...
    __stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...
    __stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1...
    api_version = 1013
    argv = [r'f:\JoeyCodes\PyDocs\py_docs.py', '--worker', 'faiss', r'F:\J...
    base_exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Pyth...
    base_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
    builtin_module_names = ('_abc', '_ast', '_bisect', '_blake2', '_codecs...
    byteorder = 'little'
    copyright = 'Copyright (c) 2001-2023 Python Software Foundati...ematis...
    dllhandle = 140727031824384
    dont_write_bytecode = False
    exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
    executable = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
    flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ding=0, saf...
    float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...
    float_repr_style = 'short'
    hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash1...
    hexversion = 51119856
    implementation = namespace(name='cpython', cache_tag='cpython-312...as...
    int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4, ..._str_dig...
    maxsize = 9223372036854775807
    maxunicode = 1114111
    meta_path = [<_distutils_hack.DistutilsMetaFinder object>, <class '_fr...
    modules = {'__future__': <module '__future__' from 'C:\\Users\\Youse\\...
    orig_argv = [r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
    path = [r'f:\JoeyCodes\PyDocs', r'C:\Users\Youse\AppData\Local\Program...
    path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...
    path_importer_cache = {r'C:\Users\Youse\AppData\Local\Programs\Python\...
    platform = 'win32'
    platlibdir = 'DLLs'
    prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312'
    pycache_prefix = None
    stderr = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1252'...
    stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
    stdlib_module_names = frozenset({'__future__', '_abc', '_aix_support',...
    stdout = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1252'...
    thread_info = sys.thread_info(name='nt', lock=None, version=None)
    version = '3.12.6 (tags/v3.12.6:a4a2d2b, Sep  6 2024, 20:11:23) [MSC v...
    version_info = sys.version_info(major=3, minor=12, micro=6, releaselev...
    warnoptions = []
    winver = '3.12'

FILE
    (built-in)

Python Library Documentation: class int_minheap_array_t in module faiss.swigfaiss

class int_minheap_array_t(builtins.object)
 |   a template structure for a set of [min|max]-heaps it is tailored
 |  so that the actual data of the heaps can just live in compact
 |  arrays.
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__ = _swig_repr(self) from faiss.swigfaiss
 |
 |  addn(self, nj, vin, j0=0, i0=0, ni=-1)
 |       add nj elements to heaps i0:i0+ni, with sequential ids
 |
 |      :type nj: int
 |      :param nj:    nb of elements to add to each heap
 |      :type vin: int
 |      :param vin:   elements to add, size ni * nj
 |      :type j0: int, optional
 |      :param j0:    add this to the ids that are added
 |      :type i0: int, optional
 |      :param i0:    first heap to update
 |      :type ni: int, optional
 |      :param ni:    nb of elements to update (-1 = use nh)
 |
 |  addn_query_subset_with_ids(self, nsubset, subset, nj, vin, id_in=None, id_stride=0)
 |       same as addn_with_ids, but for just a subset of queries
 |
 |      :type nsubset: int
 |      :param nsubset:  number of query entries to update
 |      :type subset: int
 |      :param subset:   indexes of queries to update, in 0..nh-1, size nsubset
 |
 |  addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1)
 |       same as addn
 |
 |      :type id_in: int, optional
 |      :param id_in:     ids of the elements to add, size ni * nj
 |      :type id_stride: int, optional
 |      :param id_stride: stride for id_in
 |
 |  get_ids(self, key)
 |      Corresponding identifiers
 |
 |  get_val(self, key)
 |      Return the list of values for a heap
 |
 |  heapify(self)
 |      prepare all the heaps before adding
 |
 |  per_line_extrema(self, vals_out, idx_out)
 |       this is not really a heap function. It just finds the per-line
 |        extrema of each line of array D
 |      :type vals_out: int
 |      :param vals_out:    extreme value of each line (size nh, or NULL)
 |      :type idx_out: int
 |      :param idx_out:     index of extreme value (size nh or NULL)
 |
 |  reorder(self)
 |      reorder all the heaps
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __swig_destroy__ = delete_int_minheap_array_t(...)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ids
 |      identifiers (size nh * k)
 |
 |  k
 |      allocated size per heap
 |
 |  nh
 |      number of heaps
 |
 |  thisown
 |      The membership flag
 |
 |  val
 |      values (distances or similarities), size nh * k

Python Library Documentation: package faiss

NAME
    faiss

DESCRIPTION
    # Copyright (c) Facebook, Inc. and its affiliates.
    #
    # This source code is licensed under the MIT license found in the
    # LICENSE file in the root directory of this source tree.

PACKAGE CONTENTS
    _swigfaiss
    array_conversions
    class_wrappers
    contrib (package)
    extra_wrappers
    gpu_wrappers
    loader
    swigfaiss

CLASSES
    builtins.object
        TimeoutGuard

    class TimeoutGuard(builtins.object)
     |  TimeoutGuard(timeout_in_seconds: float)
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, timeout_in_seconds: float)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    add_ref_in_constructor(the_class, parameter_no)

    add_ref_in_function(function_name, parameter_no)

    add_ref_in_method(the_class, method_name, parameter_no)

    add_ref_in_method_explicit_own(the_class, method_name)

    add_to_referenced_objects(self, ref)

    deserialize_index(data, io_flags=0)

    deserialize_index_binary(data)

    range_search_with_parameters(index, x, radius, params=None, output_stats=False)

    search_with_parameters(index, x, k, params=None, output_stats=False)

    serialize_index(index, io_flags=0)
        convert an index to a numpy uint8 array

    serialize_index_binary(index)
        convert an index to a numpy uint8 array

DATA
    APPROX_TOPK_BUCKETS_B16_D2 = 3
    APPROX_TOPK_BUCKETS_B32_D2 = 1
    APPROX_TOPK_BUCKETS_B8_D2 = 4
    APPROX_TOPK_BUCKETS_B8_D3 = 2
    ClusteringInitMethod_AFK_MC2 = 2
    ClusteringInitMethod_KMEANS_PLUS_PLUS = 1
    ClusteringInitMethod_RANDOM = 0
    EXACT_TOPK = 0
    FAISS_VERSION_MAJOR = 1
    FAISS_VERSION_MINOR = 14
    FAISS_VERSION_PATCH = 3
    Float16 = 1
    Float32 = 0
    IO_FLAG_MMAP = 1684996104
    IO_FLAG_MMAP_IFC = 512
    IO_FLAG_ONDISK_SAME_DIR = 4
    IO_FLAG_PQ_SKIP_SDC_TABLE = 32
    IO_FLAG_READ_ONLY = 2
    IO_FLAG_SKIP_IVF_DATA = 8
    IO_FLAG_SKIP_PRECOMPUTE_TABLE = 16
    IO_FLAG_SKIP_STORAGE = 1
    Int8 = 3
    METRIC_BrayCurtis = 21
    METRIC_Canberra = 20
    METRIC_GOWER = 25
    METRIC_INNER_PRODUCT = 0
    METRIC_Jaccard = 23
    METRIC_JensenShannon = 22
    METRIC_L1 = 2
    METRIC_L2 = 1
    METRIC_Linf = 3
    METRIC_Lp = 4
    METRIC_NaNEuclidean = 24
    SHARED_PTR_DISOWN = 0
    SIMDLevel_ARM_NEON = 4
    SIMDLevel_ARM_SVE = 5
    SIMDLevel_AVX2 = 1
    SIMDLevel_AVX512 = 2
    SIMDLevel_AVX512_SPR = 3
    SIMDLevel_COUNT = 7
    SIMDLevel_NONE = 0
    SIMDLevel_RISCV_RVV = 6
    SINGLE_SIMD_LEVEL = 0
    SINGLE_SIMD_LEVEL_256 = 0
    SINGLE_SIMD_LEVEL_512 = 0
    UInt8 = 2
    VERSION_STRING = '1.14.3'
    Z_MAX_BY_QB = <Swig Object of type 'float *'>
    base_prefix = 'UInt64'
    cvar = <Swig global variables>
    depr_prefix = 'Uint64'
    deprecated_name_map = {'Byte': 'UInt8', 'Char': 'Int8', 'Double': 'Flo...
    hamdis_tab_ham_bytes = <Swig Object of type 'unsigned char *'>
    has_AVX2 = True
    has_AVX512 = False
    has_AVX512_SPR = False
    has_SVE = False
    instruction_sets = {'AVX', 'AVX2', 'F16C', 'FMA3', 'MMX', 'POPCNT', .....
    loaded = False
    logger = <Logger faiss (WARNING)>
    opt_env_variable_name = 'FAISS_OPT_LEVEL'
    opt_level = None
    sizeof_long = 4
    symbol = 'write_index_binary'
    vector_name_map = {'Byte': 'uint8', 'Char': 'int8', 'Double': 'float64...

VERSION
    1.14.3

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\faiss\__init__.py

Python Library Documentation: function to_simd_level in module faiss.swigfaiss

to_simd_level(level_str)
    Parse string to SIMDLevel. Throws FaissException for invalid strings.

Python Library Documentation: function to_string in module faiss.swigfaiss

to_string(level)
    Convert SIMDLevel to string. Throws FaissException for invalid level.

Python Library Documentation: function try_extract_index_ivf in module faiss.swigfaiss

try_extract_index_ivf(*args)
    same as above but returns nullptr instead of throwing on failure

Python Library Documentation: function unpack_bitstrings in module faiss.extra_wrappers

unpack_bitstrings(b, M_or_nbits, nbit=None)
    Unpack a set integers (i, j) where i=0:n and j=0:M from
    n bitstrings (encoded as uint8s).
    Input is an uint8 array of size (n, code_size), where code_size is
    such that at most 7 bits per code are wasted.

    Two forms:
    - when called with (array, M, nbit): there are M entries of size
      nbit per row
    - when called with (array, nbits): element (i, j) is encoded in
      nbits[j] bits

Python Library Documentation: function unpack_sign_bits_from_packed in module faiss.swigfaiss

unpack_sign_bits_from_packed(block, bbs, nsq, offset, block_stride, sign_bits_out)
    Extract sign bits from PQ4-interleaved block into flat byte packing.
    Like CodePackerRaBitQ::unpack_1 but sign-bits-only and with the
    vector's in-block address hoisted out of the per-SQ loop.

Python Library Documentation: function vector_float_to_array in module faiss.array_conversions

vector_float_to_array(v)

Python Library Documentation: dict object

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |
 |  Built-in subclasses:
 |      StgDict
 |
 |  Methods defined here:
 |
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, 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__(self, key, /)
 |      Return self[key].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __ior__(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.
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __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
 |
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  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 the key is not found, return the default if given; otherwise,
 |      raise a KeyError.
 |
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  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
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  fromkeys(iterable, value=None, /)
 |      Create a new dictionary with keys from iterable and values set to value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Python Library Documentation: function vector_to_array in module faiss.array_conversions

vector_to_array(v)
    convert a C++ vector to a numpy array

Python Library Documentation: module warnings

NAME
    warnings - Python part of the warnings subsystem.

MODULE REFERENCE
    https://docs.python.org/3.12/library/warnings.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

CLASSES
    builtins.object
        catch_warnings

    class catch_warnings(builtins.object)
     |  catch_warnings(*, record=False, module=None, action=None, category=<class 'Warning'>, lineno=0, append=False)
     |
     |  A context manager that copies and restores the warnings filter upon
     |  exiting the context.
     |
     |  The 'record' argument specifies whether warnings should be captured by a
     |  custom implementation of warnings.showwarning() and be appended to a list
     |  returned by the context manager. Otherwise None is returned by the context
     |  manager. The objects appended to the list are arguments whose attributes
     |  mirror the arguments to showwarning().
     |
     |  The 'module' argument is to specify an alternative module to the module
     |  named 'warnings' and imported under that name. This argument is only useful
     |  when testing the warnings module itself.
     |
     |  If the 'action' argument is not None, the remaining arguments are passed
     |  to warnings.simplefilter() as if it were called immediately on entering the
     |  context.
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, *exc_info)
     |
     |  __init__(self, *, record=False, module=None, action=None, category=<class 'Warning'>, lineno=0, append=False)
     |      Specify whether to record warnings and if an alternative module
     |      should be used other than sys.modules['warnings'].
     |
     |      For compatibility with Python 3.0, please consider all arguments to be
     |      keyword-only.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    filterwarnings(action, message='', category=<class 'Warning'>, module='', lineno=0, append=False)
        Insert an entry into the list of warnings filters (at the front).

        'action' -- one of "error", "ignore", "always", "default", "module",
                    or "once"
        'message' -- a regex that the warning message must match
        'category' -- a class that the warning must be a subclass of
        'module' -- a regex that the module name must match
        'lineno' -- an integer line number, 0 matches all warnings
        'append' -- if true, append to the list of filters

    formatwarning(message, category, filename, lineno, line=None)
        Function to format a warning the standard way.

    resetwarnings()
        Clear the list of warning filters, so that no filters are active.

    showwarning(message, category, filename, lineno, file=None, line=None)
        Hook to write a warning to a file; replace if you like.

    simplefilter(action, category=<class 'Warning'>, lineno=0, append=False)
        Insert a simple entry into the list of warnings filters (at the front).

        A simple filter matches all modules and messages.
        'action' -- one of "error", "ignore", "always", "default", "module",
                    or "once"
        'category' -- a class that the warning must be a subclass of
        'lineno' -- an integer line number, 0 matches all warnings
        'append' -- if true, append to the list of filters

    warn(...)
        Issue a warning, or maybe ignore it or raise an exception.

        message
          Text of the warning message.
        category
          The Warning category subclass. Defaults to UserWarning.
        stacklevel
          How far up the call stack to make this warning appear. A value of 2 for
          example attributes the warning to the caller of the code calling warn().
        source
          If supplied, the destroyed object which emitted a ResourceWarning
        skip_file_prefixes
          An optional tuple of module filename prefixes indicating frames to skip
          during stacklevel computations for stack frame attribution.

    warn_explicit(...)
        Issue a warning, or maybe ignore it or raise an exception.

DATA
    __all__ = ['warn', 'warn_explicit', 'showwarning', 'formatwarning', 'f...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\warnings.py

Python Library Documentation: function write_InvertedLists in module faiss.swigfaiss

write_InvertedLists(ils, f)

Python Library Documentation: function write_ProductQuantizer in module faiss.swigfaiss

write_ProductQuantizer(*args)

Python Library Documentation: function write_VectorTransform in module faiss.swigfaiss

write_VectorTransform(*args)

Python Library Documentation: function write_index in module faiss.swigfaiss

write_index(*args)

Python Library Documentation: function write_index_binary in module faiss.swigfaiss

write_index_binary(*args)